├── .clang-format ├── .gitattributes ├── .gitignore ├── CMakeLists.txt ├── CppProperties.json ├── LICENSE ├── Memory ├── GameData.cpp ├── GameData.h ├── Hooks.cpp ├── Hooks.h ├── MinHook.h ├── SlimMem.cpp └── SlimMem.h ├── Packet.rc ├── Packet.sln ├── Packet.vcxproj ├── Packet ├── Command │ ├── CommandMgr.cpp │ ├── CommandMgr.h │ └── Commands │ │ ├── BindCommand.cpp │ │ ├── BindCommand.h │ │ ├── CommandBlockExploitCommand.cpp │ │ ├── CommandBlockExploitCommand.h │ │ ├── ConfigCommand.cpp │ │ ├── ConfigCommand.h │ │ ├── CoordsCommand.cpp │ │ ├── CoordsCommand.h │ │ ├── CreditCommand.cpp │ │ ├── CreditCommand.h │ │ ├── DamageCommand.cpp │ │ ├── DamageCommand.h │ │ ├── DupeCommand.cpp │ │ ├── DupeCommand.h │ │ ├── EjectCommand.cpp │ │ ├── EjectCommand.h │ │ ├── EnchantCommand.cpp │ │ ├── EnchantCommand.h │ │ ├── ExecuteCommand.cpp │ │ ├── ExecuteCommand.h │ │ ├── FriendListCommand.cpp │ │ ├── FriendListCommand.h │ │ ├── GameModeCommand.cpp │ │ ├── GameModeCommand.h │ │ ├── GiveCommand.cpp │ │ ├── GiveCommand.h │ │ ├── HelpCommand.cpp │ │ ├── HelpCommand.h │ │ ├── HideCommand.cpp │ │ ├── HideCommand.h │ │ ├── ICommand.cpp │ │ ├── ICommand.h │ │ ├── IDCommand.cpp │ │ ├── IDCommand.h │ │ ├── KitCommand.cpp │ │ ├── KitCommand.h │ │ ├── ModulesCommand.cpp │ │ ├── ModulesCommand.h │ │ ├── NameSpoofCommand.cpp │ │ ├── NameSpoofCommand.h │ │ ├── NbtCommand.cpp │ │ ├── NbtCommand.h │ │ ├── PanicCommand.cpp │ │ ├── PanicCommand.h │ │ ├── PartyCommand.cpp │ │ ├── PartyCommand.h │ │ ├── PlayerTeleportCommand.cpp │ │ ├── PlayerTeleportCommand.h │ │ ├── RelativeTeleportCommand.cpp │ │ ├── RelativeTeleportCommand.h │ │ ├── SayCommand.cpp │ │ ├── SayCommand.h │ │ ├── ScriptCommand.cpp │ │ ├── ScriptCommand.h │ │ ├── ServerCommand.cpp │ │ ├── ServerCommand.h │ │ ├── SetprefixCommand.cpp │ │ ├── SetprefixCommand.h │ │ ├── SpammerCommand.cpp │ │ ├── SpammerCommand.h │ │ ├── TeleportCommand.cpp │ │ ├── TeleportCommand.h │ │ ├── TestCommand.cpp │ │ ├── TestCommand.h │ │ ├── ToggleCommand.cpp │ │ ├── ToggleCommand.h │ │ ├── TopCommand.cpp │ │ ├── TopCommand.h │ │ ├── UnbindCommand.cpp │ │ ├── UnbindCommand.h │ │ ├── WatermarkCommand.cpp │ │ ├── WatermarkCommand.h │ │ ├── WaypointCommand.cpp │ │ ├── WaypointCommand.h │ │ ├── desktop.ini │ │ ├── setoffhandCommand.cpp │ │ └── setoffhandCommand.h ├── Config │ ├── AccountInformation.cpp │ ├── AccountInformation.h │ ├── ConfigManager.cpp │ └── ConfigManager.h ├── DrawUtils.cpp ├── DrawUtils.h ├── FriendList │ ├── FriendList.cpp │ └── FriendList.h ├── GuiUtils.cpp ├── GuiUtils.h ├── ImmediateGui.cpp ├── ImmediateGui.h ├── Loader.cpp ├── Loader.h ├── Menu │ ├── ClickGui.cpp │ ├── ClickGui.h │ ├── HudEditor.cpp │ ├── HudEditor.h │ ├── TabGui.cpp │ └── TabGui.h ├── Module │ ├── ModuleManager.cpp │ ├── ModuleManager.h │ └── Modules │ │ ├── Aimbot.cpp │ │ ├── Aimbot.h │ │ ├── Animations.cpp │ │ ├── Animations.h │ │ ├── AntiBot.cpp │ │ ├── AntiBot.h │ │ ├── AntiImmobile.cpp │ │ ├── AntiImmobile.h │ │ ├── AntiVoid.cpp │ │ ├── AntiVoid.h │ │ ├── ArrayList.cpp │ │ ├── ArrayList.h │ │ ├── AutoArmor.cpp │ │ ├── AutoArmor.h │ │ ├── AutoClicker.cpp │ │ ├── AutoClicker.h │ │ ├── AutoTotem.cpp │ │ ├── AutoTotem.h │ │ ├── BehindAura.cpp │ │ ├── BehindAura.h │ │ ├── Blink.cpp │ │ ├── Blink.h │ │ ├── BlockESP.cpp │ │ ├── BlockESP.h │ │ ├── BlockOutline.cpp │ │ ├── BlockOutline.h │ │ ├── BlockReach.cpp │ │ ├── BlockReach.h │ │ ├── BreadCrumbs.cpp │ │ ├── BreadCrumbs.h │ │ ├── Breaker.cpp │ │ ├── Breaker.h │ │ ├── CameraMod.cpp │ │ ├── CameraMod.h │ │ ├── ChatBypass.cpp │ │ ├── ChatBypass.h │ │ ├── ChestAura.cpp │ │ ├── ChestAura.h │ │ ├── ChestESP.cpp │ │ ├── ChestESP.h │ │ ├── ChestStealer.cpp │ │ ├── ChestStealer.h │ │ ├── ClickGuiMod.cpp │ │ ├── ClickGuiMod.h │ │ ├── ClickTP.cpp │ │ ├── ClickTP.h │ │ ├── Criticals.cpp │ │ ├── Criticals.h │ │ ├── CrystalAura.cpp │ │ ├── CrystalAura.h │ │ ├── CustomSky.cpp │ │ ├── CustomSky.h │ │ ├── Derp.cpp │ │ ├── Derp.h │ │ ├── Disabler.cpp │ │ ├── Disabler.h │ │ ├── ESP.cpp │ │ ├── ESP.h │ │ ├── EditionFaker.cpp │ │ ├── EditionFaker.h │ │ ├── Emote.cpp │ │ ├── Emote.h │ │ ├── EntityControl.cpp │ │ ├── EntityControl.h │ │ ├── ExtendedBlockReach.cpp │ │ ├── ExtendedBlockReach.h │ │ ├── FallSave.cpp │ │ ├── FallSave.h │ │ ├── FastPlace.cpp │ │ ├── FastPlace.h │ │ ├── FastStop.cpp │ │ ├── FastStop.h │ │ ├── Flight.cpp │ │ ├── Flight.h │ │ ├── FreeTP.cpp │ │ ├── FreeTP.h │ │ ├── Freecam.cpp │ │ ├── Freecam.h │ │ ├── Freelook.cpp │ │ ├── Freelook.h │ │ ├── FullBright.cpp │ │ ├── FullBright.h │ │ ├── HackerDetector.cpp │ │ ├── HackerDetector.h │ │ ├── Hitbox.cpp │ │ ├── Hitbox.h │ │ ├── HiveFly.cpp │ │ ├── HiveFly.h │ │ ├── HudEditorMod.cpp │ │ ├── HudEditorMod.h │ │ ├── HudModule.cpp │ │ ├── HudModule.h │ │ ├── InPvPFucker.cpp │ │ ├── InPvPFucker.h │ │ ├── InstaBreak.cpp │ │ ├── InstaBreak.h │ │ ├── InvManager.cpp │ │ ├── InvManager.h │ │ ├── InventoryCleaner.cpp │ │ ├── InventoryCleaner.h │ │ ├── InventoryMove.cpp │ │ ├── InventoryMove.h │ │ ├── ItemTP.cpp │ │ ├── ItemTP.h │ │ ├── JavascriptModule.cpp │ │ ├── JavascriptModule.h │ │ ├── Jesus.cpp │ │ ├── Jesus.h │ │ ├── Jetpack.cpp │ │ ├── Jetpack.h │ │ ├── KBFly.cpp │ │ ├── KBFly.h │ │ ├── Killaura.cpp │ │ ├── Killaura.h │ │ ├── LongJump.cpp │ │ ├── LongJump.h │ │ ├── MidClick.cpp │ │ ├── MidClick.h │ │ ├── Module.cpp │ │ ├── Module.h │ │ ├── NameTags.cpp │ │ ├── NameTags.h │ │ ├── Nbt.cpp │ │ ├── Nbt.h │ │ ├── NoFall.cpp │ │ ├── NoFall.h │ │ ├── NoFriends.cpp │ │ ├── NoFriends.h │ │ ├── NoJumpDelay.cpp │ │ ├── NoJumpDelay.h │ │ ├── NoPacket.cpp │ │ ├── NoPacket.h │ │ ├── NoSlow.cpp │ │ ├── NoSlow.h │ │ ├── NoSwing.cpp │ │ ├── NoSwing.h │ │ ├── Notifications.cpp │ │ ├── Notifications.h │ │ ├── Nuker.cpp │ │ ├── Nuker.h │ │ ├── Packet.cpp │ │ ├── Packet.h │ │ ├── PacketLogger.cpp │ │ ├── PacketLogger.h │ │ ├── Phase.cpp │ │ ├── Phase.h │ │ ├── PlayerList.cpp │ │ ├── PlayerList.h │ │ ├── Radar.cpp │ │ ├── Radar.h │ │ ├── RainbowSky.cpp │ │ ├── RainbowSky.h │ │ ├── Reach.cpp │ │ ├── Reach.h │ │ ├── Safewalk.cpp │ │ ├── Safewalk.h │ │ ├── Scaffold.cpp │ │ ├── Scaffold.h │ │ ├── Sneak.cpp │ │ ├── Sneak.h │ │ ├── Spammer.cpp │ │ ├── Spammer.h │ │ ├── SpawnTP.cpp │ │ ├── SpawnTP.h │ │ ├── Speed.cpp │ │ ├── Speed.h │ │ ├── Spider.cpp │ │ ├── Spider.h │ │ ├── Sprint.cpp │ │ ├── Sprint.h │ │ ├── StackableItem.cpp │ │ ├── StackableItem.h │ │ ├── Step.cpp │ │ ├── Step.h │ │ ├── Survival.cpp │ │ ├── Survival.h │ │ ├── Switcher.cpp │ │ ├── Switcher.h │ │ ├── TPAura.cpp │ │ ├── TPAura.h │ │ ├── TargetHUD.cpp │ │ ├── TargetHUD.h │ │ ├── TargetStrafe.cpp │ │ ├── TargetStrafe.h │ │ ├── TargetStrafeOld.cpp │ │ ├── TargetStrafeOld.h │ │ ├── Teams.cpp │ │ ├── Teams.h │ │ ├── TestModule.cpp │ │ ├── TestModule.h │ │ ├── TimeChanger.cpp │ │ ├── TimeChanger.h │ │ ├── Timer.cpp │ │ ├── Timer.h │ │ ├── TriggerBot.cpp │ │ ├── TriggerBot.h │ │ ├── VanillaPlus.cpp │ │ ├── VanillaPlus.h │ │ ├── Velocity.cpp │ │ ├── Velocity.h │ │ ├── Watermark.cpp │ │ ├── Watermark.h │ │ ├── Waypoints.cpp │ │ ├── Waypoints.h │ │ ├── XP.cpp │ │ ├── XP.h │ │ ├── Xray.cpp │ │ ├── Xray.h │ │ ├── Zoom.cpp │ │ └── Zoom.h ├── Scripting │ ├── Functions │ │ ├── CommandManagerFunctions.cpp │ │ ├── CommandManagerFunctions.h │ │ ├── DrawFunctions.cpp │ │ ├── DrawFunctions.h │ │ ├── EntityFunctions.cpp │ │ ├── EntityFunctions.h │ │ ├── GameFunctions.cpp │ │ ├── GameFunctions.h │ │ ├── GlobalFunctions.cpp │ │ ├── GlobalFunctions.h │ │ ├── HorionFunctions.cpp │ │ ├── HorionFunctions.h │ │ ├── InventoryFunctions.cpp │ │ ├── InventoryFunctions.h │ │ ├── LevelFunctions.cpp │ │ ├── LevelFunctions.h │ │ ├── LocalPlayerFunctions.cpp │ │ ├── LocalPlayerFunctions.h │ │ ├── ModuleManagerFunctions.cpp │ │ ├── ModuleManagerFunctions.h │ │ ├── Vector2Functions.cpp │ │ ├── Vector2Functions.h │ │ ├── Vector3Functions.cpp │ │ └── Vector3Functions.h │ ├── JsScriptModule.cpp │ ├── JsScriptModule.h │ ├── ScriptInstance.cpp │ ├── ScriptInstance.h │ ├── ScriptManager.cpp │ └── ScriptManager.h └── path │ ├── JoeConstants.cpp │ ├── JoeConstants.h │ ├── JoeMovementController.cpp │ ├── JoeMovementController.h │ ├── JoePath.cpp │ ├── JoePath.h │ ├── JoePathFinder.cpp │ ├── JoePathFinder.h │ ├── JoeSegment.cpp │ ├── JoeSegment.h │ └── goals │ ├── JoeGoal.cpp │ ├── JoeGoal.h │ ├── JoeGoalXYZ.cpp │ ├── JoeGoalXYZ.h │ ├── JoeGoalXZ.cpp │ ├── JoeGoalXZ.h │ ├── JoeGoalY.cpp │ └── JoeGoalY.h ├── README.md ├── SDK ├── CBlockLegacy.cpp ├── CBlockLegacy.h ├── CCamera.cpp ├── CCamera.h ├── CChestBlockActor.cpp ├── CChestBlockActor.h ├── CClientInstance.cpp ├── CClientInstance.h ├── CClientInstanceScreenModel.h ├── CComplexInventoryTransaction.cpp ├── CComplexInventoryTransaction.h ├── CEntity.cpp ├── CEntity.h ├── CEntityList.h ├── CGameMode.cpp ├── CGameMode.h ├── CGameSettingsInput.h ├── CHIDController.h ├── CImageBuffer.h ├── CInventory.cpp ├── CInventory.h ├── CInventoryTransaction.cpp ├── CInventoryTransaction.h ├── CItem.cpp ├── CItem.h ├── CLoopbackPacketSender.h ├── CMinecraftUIRenderContext.cpp ├── CMinecraftUIRenderContext.h ├── CMoveInputHandler.cpp ├── CMoveInputHandler.h ├── CPacket.cpp ├── CPacket.h ├── CRakNetInstance.h ├── CUIScene.h ├── MatrixStack.cpp ├── MatrixStack.h ├── MojangsonToken.h ├── Tag.cpp ├── Tag.h ├── Tessellator.cpp ├── Tessellator.h ├── TextHolder.cpp ├── TextHolder.h └── Weather.h ├── Utils ├── ChakraHelper.h ├── DllHelper.h ├── HMath.h ├── Json.hpp ├── Logger.cpp ├── Logger.h ├── SkinUtil.cpp ├── SkinUtil.h ├── Target.cpp ├── Target.h ├── TextFormat.cpp ├── TextFormat.h ├── Utils.cpp ├── Utils.h ├── VoxelIntersector.cpp ├── VoxelIntersector.h ├── keys.h └── xorstr.h ├── assets └── images │ └── logo.png ├── include ├── RegExp.h ├── StringProcess.h ├── WinHttpClient.h ├── atlrx.h ├── chakra │ ├── ChakraCommon.h │ ├── ChakraCommonWindows.h │ ├── ChakraCore.h │ ├── ChakraCoreWindows.h │ └── ChakraDebug.h ├── d3dx11.h ├── d3dx11async.h ├── d3dx11core.h ├── d3dx11effect.h └── glm │ ├── .appveyor.yml │ ├── .gitignore │ ├── .travis.yml │ ├── CMakeLists.txt │ ├── cmake │ └── glm │ │ ├── glmConfig-version.cmake │ │ └── glmConfig.cmake │ ├── copying.txt │ ├── glm │ ├── CMakeLists.txt │ ├── common.hpp │ ├── detail │ │ ├── _features.hpp │ │ ├── _fixes.hpp │ │ ├── _noise.hpp │ │ ├── _swizzle.hpp │ │ ├── _swizzle_func.hpp │ │ ├── _vectorize.hpp │ │ ├── compute_common.hpp │ │ ├── compute_vector_relational.hpp │ │ ├── func_common.inl │ │ ├── func_common_simd.inl │ │ ├── func_exponential.inl │ │ ├── func_exponential_simd.inl │ │ ├── func_geometric.inl │ │ ├── func_geometric_simd.inl │ │ ├── func_integer.inl │ │ ├── func_integer_simd.inl │ │ ├── func_matrix.inl │ │ ├── func_matrix_simd.inl │ │ ├── func_packing.inl │ │ ├── func_packing_simd.inl │ │ ├── func_trigonometric.inl │ │ ├── func_trigonometric_simd.inl │ │ ├── func_vector_relational.inl │ │ ├── func_vector_relational_simd.inl │ │ ├── glm.cpp │ │ ├── qualifier.hpp │ │ ├── setup.hpp │ │ ├── type_float.hpp │ │ ├── type_half.hpp │ │ ├── type_half.inl │ │ ├── type_mat2x2.hpp │ │ ├── type_mat2x2.inl │ │ ├── type_mat2x3.hpp │ │ ├── type_mat2x3.inl │ │ ├── type_mat2x4.hpp │ │ ├── type_mat2x4.inl │ │ ├── type_mat3x2.hpp │ │ ├── type_mat3x2.inl │ │ ├── type_mat3x3.hpp │ │ ├── type_mat3x3.inl │ │ ├── type_mat3x4.hpp │ │ ├── type_mat3x4.inl │ │ ├── type_mat4x2.hpp │ │ ├── type_mat4x2.inl │ │ ├── type_mat4x3.hpp │ │ ├── type_mat4x3.inl │ │ ├── type_mat4x4.hpp │ │ ├── type_mat4x4.inl │ │ ├── type_mat4x4_simd.inl │ │ ├── type_quat.hpp │ │ ├── type_quat.inl │ │ ├── type_quat_simd.inl │ │ ├── type_vec1.hpp │ │ ├── type_vec1.inl │ │ ├── type_vec2.hpp │ │ ├── type_vec2.inl │ │ ├── type_vec3.hpp │ │ ├── type_vec3.inl │ │ ├── type_vec4.hpp │ │ ├── type_vec4.inl │ │ └── type_vec4_simd.inl │ ├── exponential.hpp │ ├── ext.hpp │ ├── ext │ │ ├── matrix_clip_space.hpp │ │ ├── matrix_clip_space.inl │ │ ├── matrix_common.hpp │ │ ├── matrix_common.inl │ │ ├── matrix_double2x2.hpp │ │ ├── matrix_double2x2_precision.hpp │ │ ├── matrix_double2x3.hpp │ │ ├── matrix_double2x3_precision.hpp │ │ ├── matrix_double2x4.hpp │ │ ├── matrix_double2x4_precision.hpp │ │ ├── matrix_double3x2.hpp │ │ ├── matrix_double3x2_precision.hpp │ │ ├── matrix_double3x3.hpp │ │ ├── matrix_double3x3_precision.hpp │ │ ├── matrix_double3x4.hpp │ │ ├── matrix_double3x4_precision.hpp │ │ ├── matrix_double4x2.hpp │ │ ├── matrix_double4x2_precision.hpp │ │ ├── matrix_double4x3.hpp │ │ ├── matrix_double4x3_precision.hpp │ │ ├── matrix_double4x4.hpp │ │ ├── matrix_double4x4_precision.hpp │ │ ├── matrix_float2x2.hpp │ │ ├── matrix_float2x2_precision.hpp │ │ ├── matrix_float2x3.hpp │ │ ├── matrix_float2x3_precision.hpp │ │ ├── matrix_float2x4.hpp │ │ ├── matrix_float2x4_precision.hpp │ │ ├── matrix_float3x2.hpp │ │ ├── matrix_float3x2_precision.hpp │ │ ├── matrix_float3x3.hpp │ │ ├── matrix_float3x3_precision.hpp │ │ ├── matrix_float3x4.hpp │ │ ├── matrix_float3x4_precision.hpp │ │ ├── matrix_float4x2.hpp │ │ ├── matrix_float4x2_precision.hpp │ │ ├── matrix_float4x3.hpp │ │ ├── matrix_float4x3_precision.hpp │ │ ├── matrix_float4x4.hpp │ │ ├── matrix_float4x4_precision.hpp │ │ ├── matrix_int2x2.hpp │ │ ├── matrix_int2x2_sized.hpp │ │ ├── matrix_int2x3.hpp │ │ ├── matrix_int2x3_sized.hpp │ │ ├── matrix_int2x4.hpp │ │ ├── matrix_int2x4_sized.hpp │ │ ├── matrix_int3x2.hpp │ │ ├── matrix_int3x2_sized.hpp │ │ ├── matrix_int3x3.hpp │ │ ├── matrix_int3x3_sized.hpp │ │ ├── matrix_int3x4.hpp │ │ ├── matrix_int3x4_sized.hpp │ │ ├── matrix_int4x2.hpp │ │ ├── matrix_int4x2_sized.hpp │ │ ├── matrix_int4x3.hpp │ │ ├── matrix_int4x3_sized.hpp │ │ ├── matrix_int4x4.hpp │ │ ├── matrix_int4x4_sized.hpp │ │ ├── matrix_projection.hpp │ │ ├── matrix_projection.inl │ │ ├── matrix_relational.hpp │ │ ├── matrix_relational.inl │ │ ├── matrix_transform.hpp │ │ ├── matrix_transform.inl │ │ ├── matrix_uint2x2.hpp │ │ ├── matrix_uint2x2_sized.hpp │ │ ├── matrix_uint2x3.hpp │ │ ├── matrix_uint2x3_sized.hpp │ │ ├── matrix_uint2x4.hpp │ │ ├── matrix_uint2x4_sized.hpp │ │ ├── matrix_uint3x2.hpp │ │ ├── matrix_uint3x2_sized.hpp │ │ ├── matrix_uint3x3.hpp │ │ ├── matrix_uint3x3_sized.hpp │ │ ├── matrix_uint3x4.hpp │ │ ├── matrix_uint3x4_sized.hpp │ │ ├── matrix_uint4x2.hpp │ │ ├── matrix_uint4x2_sized.hpp │ │ ├── matrix_uint4x3.hpp │ │ ├── matrix_uint4x3_sized.hpp │ │ ├── matrix_uint4x4.hpp │ │ ├── matrix_uint4x4_sized.hpp │ │ ├── quaternion_common.hpp │ │ ├── quaternion_common.inl │ │ ├── quaternion_common_simd.inl │ │ ├── quaternion_double.hpp │ │ ├── quaternion_double_precision.hpp │ │ ├── quaternion_exponential.hpp │ │ ├── quaternion_exponential.inl │ │ ├── quaternion_float.hpp │ │ ├── quaternion_float_precision.hpp │ │ ├── quaternion_geometric.hpp │ │ ├── quaternion_geometric.inl │ │ ├── quaternion_relational.hpp │ │ ├── quaternion_relational.inl │ │ ├── quaternion_transform.hpp │ │ ├── quaternion_transform.inl │ │ ├── quaternion_trigonometric.hpp │ │ ├── quaternion_trigonometric.inl │ │ ├── scalar_common.hpp │ │ ├── scalar_common.inl │ │ ├── scalar_constants.hpp │ │ ├── scalar_constants.inl │ │ ├── scalar_int_sized.hpp │ │ ├── scalar_integer.hpp │ │ ├── scalar_integer.inl │ │ ├── scalar_packing.hpp │ │ ├── scalar_packing.inl │ │ ├── scalar_relational.hpp │ │ ├── scalar_relational.inl │ │ ├── scalar_uint_sized.hpp │ │ ├── scalar_ulp.hpp │ │ ├── scalar_ulp.inl │ │ ├── vector_bool1.hpp │ │ ├── vector_bool1_precision.hpp │ │ ├── vector_bool2.hpp │ │ ├── vector_bool2_precision.hpp │ │ ├── vector_bool3.hpp │ │ ├── vector_bool3_precision.hpp │ │ ├── vector_bool4.hpp │ │ ├── vector_bool4_precision.hpp │ │ ├── vector_common.hpp │ │ ├── vector_common.inl │ │ ├── vector_double1.hpp │ │ ├── vector_double1_precision.hpp │ │ ├── vector_double2.hpp │ │ ├── vector_double2_precision.hpp │ │ ├── vector_double3.hpp │ │ ├── vector_double3_precision.hpp │ │ ├── vector_double4.hpp │ │ ├── vector_double4_precision.hpp │ │ ├── vector_float1.hpp │ │ ├── vector_float1_precision.hpp │ │ ├── vector_float2.hpp │ │ ├── vector_float2_precision.hpp │ │ ├── vector_float3.hpp │ │ ├── vector_float3_precision.hpp │ │ ├── vector_float4.hpp │ │ ├── vector_float4_precision.hpp │ │ ├── vector_int1.hpp │ │ ├── vector_int1_sized.hpp │ │ ├── vector_int2.hpp │ │ ├── vector_int2_sized.hpp │ │ ├── vector_int3.hpp │ │ ├── vector_int3_sized.hpp │ │ ├── vector_int4.hpp │ │ ├── vector_int4_sized.hpp │ │ ├── vector_integer.hpp │ │ ├── vector_integer.inl │ │ ├── vector_packing.hpp │ │ ├── vector_packing.inl │ │ ├── vector_relational.hpp │ │ ├── vector_relational.inl │ │ ├── vector_uint1.hpp │ │ ├── vector_uint1_sized.hpp │ │ ├── vector_uint2.hpp │ │ ├── vector_uint2_sized.hpp │ │ ├── vector_uint3.hpp │ │ ├── vector_uint3_sized.hpp │ │ ├── vector_uint4.hpp │ │ ├── vector_uint4_sized.hpp │ │ ├── vector_ulp.hpp │ │ └── vector_ulp.inl │ ├── fwd.hpp │ ├── geometric.hpp │ ├── glm.hpp │ ├── gtc │ │ ├── bitfield.hpp │ │ ├── bitfield.inl │ │ ├── color_space.hpp │ │ ├── color_space.inl │ │ ├── constants.hpp │ │ ├── constants.inl │ │ ├── epsilon.hpp │ │ ├── epsilon.inl │ │ ├── integer.hpp │ │ ├── integer.inl │ │ ├── matrix_access.hpp │ │ ├── matrix_access.inl │ │ ├── matrix_integer.hpp │ │ ├── matrix_inverse.hpp │ │ ├── matrix_inverse.inl │ │ ├── matrix_transform.hpp │ │ ├── matrix_transform.inl │ │ ├── noise.hpp │ │ ├── noise.inl │ │ ├── packing.hpp │ │ ├── packing.inl │ │ ├── quaternion.hpp │ │ ├── quaternion.inl │ │ ├── quaternion_simd.inl │ │ ├── random.hpp │ │ ├── random.inl │ │ ├── reciprocal.hpp │ │ ├── reciprocal.inl │ │ ├── round.hpp │ │ ├── round.inl │ │ ├── type_aligned.hpp │ │ ├── type_precision.hpp │ │ ├── type_precision.inl │ │ ├── type_ptr.hpp │ │ ├── type_ptr.inl │ │ ├── ulp.hpp │ │ ├── ulp.inl │ │ └── vec1.hpp │ ├── gtx │ │ ├── associated_min_max.hpp │ │ ├── associated_min_max.inl │ │ ├── bit.hpp │ │ ├── bit.inl │ │ ├── closest_point.hpp │ │ ├── closest_point.inl │ │ ├── color_encoding.hpp │ │ ├── color_encoding.inl │ │ ├── color_space.hpp │ │ ├── color_space.inl │ │ ├── color_space_YCoCg.hpp │ │ ├── color_space_YCoCg.inl │ │ ├── common.hpp │ │ ├── common.inl │ │ ├── compatibility.hpp │ │ ├── compatibility.inl │ │ ├── component_wise.hpp │ │ ├── component_wise.inl │ │ ├── dual_quaternion.hpp │ │ ├── dual_quaternion.inl │ │ ├── easing.hpp │ │ ├── easing.inl │ │ ├── euler_angles.hpp │ │ ├── euler_angles.inl │ │ ├── extend.hpp │ │ ├── extend.inl │ │ ├── extended_min_max.hpp │ │ ├── extended_min_max.inl │ │ ├── exterior_product.hpp │ │ ├── exterior_product.inl │ │ ├── fast_exponential.hpp │ │ ├── fast_exponential.inl │ │ ├── fast_square_root.hpp │ │ ├── fast_square_root.inl │ │ ├── fast_trigonometry.hpp │ │ ├── fast_trigonometry.inl │ │ ├── float_notmalize.inl │ │ ├── functions.hpp │ │ ├── functions.inl │ │ ├── gradient_paint.hpp │ │ ├── gradient_paint.inl │ │ ├── handed_coordinate_space.hpp │ │ ├── handed_coordinate_space.inl │ │ ├── hash.hpp │ │ ├── hash.inl │ │ ├── integer.hpp │ │ ├── integer.inl │ │ ├── intersect.hpp │ │ ├── intersect.inl │ │ ├── io.hpp │ │ ├── io.inl │ │ ├── log_base.hpp │ │ ├── log_base.inl │ │ ├── matrix_cross_product.hpp │ │ ├── matrix_cross_product.inl │ │ ├── matrix_decompose.hpp │ │ ├── matrix_decompose.inl │ │ ├── matrix_factorisation.hpp │ │ ├── matrix_factorisation.inl │ │ ├── matrix_interpolation.hpp │ │ ├── matrix_interpolation.inl │ │ ├── matrix_major_storage.hpp │ │ ├── matrix_major_storage.inl │ │ ├── matrix_operation.hpp │ │ ├── matrix_operation.inl │ │ ├── matrix_query.hpp │ │ ├── matrix_query.inl │ │ ├── matrix_transform_2d.hpp │ │ ├── matrix_transform_2d.inl │ │ ├── mixed_product.hpp │ │ ├── mixed_product.inl │ │ ├── norm.hpp │ │ ├── norm.inl │ │ ├── normal.hpp │ │ ├── normal.inl │ │ ├── normalize_dot.hpp │ │ ├── normalize_dot.inl │ │ ├── number_precision.hpp │ │ ├── number_precision.inl │ │ ├── optimum_pow.hpp │ │ ├── optimum_pow.inl │ │ ├── orthonormalize.hpp │ │ ├── orthonormalize.inl │ │ ├── perpendicular.hpp │ │ ├── perpendicular.inl │ │ ├── polar_coordinates.hpp │ │ ├── polar_coordinates.inl │ │ ├── projection.hpp │ │ ├── projection.inl │ │ ├── quaternion.hpp │ │ ├── quaternion.inl │ │ ├── range.hpp │ │ ├── raw_data.hpp │ │ ├── raw_data.inl │ │ ├── rotate_normalized_axis.hpp │ │ ├── rotate_normalized_axis.inl │ │ ├── rotate_vector.hpp │ │ ├── rotate_vector.inl │ │ ├── scalar_multiplication.hpp │ │ ├── scalar_relational.hpp │ │ ├── scalar_relational.inl │ │ ├── spline.hpp │ │ ├── spline.inl │ │ ├── std_based_type.hpp │ │ ├── std_based_type.inl │ │ ├── string_cast.hpp │ │ ├── string_cast.inl │ │ ├── texture.hpp │ │ ├── texture.inl │ │ ├── transform.hpp │ │ ├── transform.inl │ │ ├── transform2.hpp │ │ ├── transform2.inl │ │ ├── type_aligned.hpp │ │ ├── type_aligned.inl │ │ ├── type_trait.hpp │ │ ├── type_trait.inl │ │ ├── vec_swizzle.hpp │ │ ├── vector_angle.hpp │ │ ├── vector_angle.inl │ │ ├── vector_query.hpp │ │ ├── vector_query.inl │ │ ├── wrap.hpp │ │ └── wrap.inl │ ├── integer.hpp │ ├── mat2x2.hpp │ ├── mat2x3.hpp │ ├── mat2x4.hpp │ ├── mat3x2.hpp │ ├── mat3x3.hpp │ ├── mat3x4.hpp │ ├── mat4x2.hpp │ ├── mat4x3.hpp │ ├── mat4x4.hpp │ ├── matrix.hpp │ ├── packing.hpp │ ├── simd │ │ ├── common.h │ │ ├── exponential.h │ │ ├── geometric.h │ │ ├── integer.h │ │ ├── matrix.h │ │ ├── neon.h │ │ ├── packing.h │ │ ├── platform.h │ │ ├── trigonometric.h │ │ └── vector_relational.h │ ├── trigonometric.hpp │ ├── vec2.hpp │ ├── vec3.hpp │ ├── vec4.hpp │ └── vector_relational.hpp │ ├── manual.md │ ├── readme.md │ └── util │ ├── autoexp.txt │ ├── autoexp.vc2010.dat │ ├── glm.natvis │ └── usertype.dat ├── minhook └── MinHook.x64.lib ├── packages.config ├── resource.h └── resources ├── Steve.dat ├── Steve_old.dat ├── coolroblox.json └── oldroblox.json /.clang-format: -------------------------------------------------------------------------------- 1 | --- 2 | BasedOnStyle: Google 3 | UseTab: ForContinuationAndIndentation 4 | IndentWidth: 4 5 | TabWidth: 4 6 | IndentCaseLabels: false 7 | ColumnLimit: 0 8 | BreakBeforeBraces: Attach 9 | AccessModifierOffset: -4 10 | --- 11 | Language: Cpp -------------------------------------------------------------------------------- /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | -------------------------------------------------------------------------------- /CppProperties.json: -------------------------------------------------------------------------------- 1 | { 2 | "configurations": [ 3 | { 4 | "inheritEnvironments": [ 5 | "msvc_x86" 6 | ], 7 | "name": "x86-Debug", 8 | "includePath": [ 9 | "${env.INCLUDE}", 10 | "${workspaceRoot}\\**" 11 | ], 12 | "defines": [ 13 | "WIN32", 14 | "_DEBUG", 15 | "UNICODE", 16 | "_UNICODE" 17 | ], 18 | "intelliSenseMode": "windows-msvc-x86" 19 | } 20 | ] 21 | } -------------------------------------------------------------------------------- /Packet.rc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacketDeveloper/Packet-Source/6b86a27d9c4af265fe1cde877736976870184665/Packet.rc -------------------------------------------------------------------------------- /Packet/Command/Commands/BindCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | #include "ICommand.h" 5 | 6 | class BindCommand : public IMCCommand { 7 | public: 8 | BindCommand(); 9 | ~BindCommand(); 10 | 11 | // Inherited via IMCCommand 12 | virtual bool execute(std::vector* args) override; 13 | }; 14 | -------------------------------------------------------------------------------- /Packet/Command/Commands/CommandBlockExploitCommand.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacketDeveloper/Packet-Source/6b86a27d9c4af265fe1cde877736976870184665/Packet/Command/Commands/CommandBlockExploitCommand.cpp -------------------------------------------------------------------------------- /Packet/Command/Commands/CommandBlockExploitCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | 4 | class CommandBlockExploitCommand : public IMCCommand { 5 | public: 6 | CommandBlockExploitCommand(); 7 | ~CommandBlockExploitCommand(); 8 | 9 | // Inherited via IMCCommand 10 | virtual bool execute(std::vector* args) override; 11 | }; 12 | -------------------------------------------------------------------------------- /Packet/Command/Commands/ConfigCommand.cpp: -------------------------------------------------------------------------------- 1 | #include "ConfigCommand.h" 2 | 3 | ConfigCommand::ConfigCommand() : IMCCommand("config", "Load/save configs", " ") { 4 | registerAlias("cnfg"); 5 | registerAlias("cfg"); 6 | registerAlias("c"); 7 | } 8 | 9 | ConfigCommand::~ConfigCommand() { 10 | } 11 | 12 | bool ConfigCommand::execute(std::vector* args) { 13 | if (args->at(1) == "load" || args->at(1) == "l") { 14 | std::string name = args->at(2); 15 | configMgr->loadConfig(name, false); 16 | return true; 17 | } else if (args->at(1) == "new" || args->at(1) == "n") { 18 | std::string name = args->at(2); 19 | configMgr->loadConfig(name, true); 20 | return true; 21 | } else if (args->at(1) == "save" || args->at(1) == "s") { 22 | configMgr->saveConfig(); 23 | clientMessageF("[Packet] %sSuccessfully saved config %s%s%s!", GREEN, GRAY, configMgr->currentConfig.c_str(), GREEN); 24 | return true; 25 | } 26 | return false; 27 | } -------------------------------------------------------------------------------- /Packet/Command/Commands/ConfigCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | #include "..\..\Config\ConfigManager.h" 4 | 5 | class ConfigCommand : public IMCCommand { 6 | public: 7 | ConfigCommand(); 8 | ~ConfigCommand(); 9 | 10 | // Inherited via IMCCommand 11 | virtual bool execute(std::vector* args) override; 12 | }; -------------------------------------------------------------------------------- /Packet/Command/Commands/CoordsCommand.cpp: -------------------------------------------------------------------------------- 1 | #include "CoordsCommand.h" 2 | 3 | CoordsCommand::CoordsCommand() : IMCCommand("coords", "Prints your coordinates", "") { 4 | registerAlias("pos"); 5 | } 6 | 7 | CoordsCommand::~CoordsCommand() { 8 | } 9 | 10 | bool CoordsCommand::execute(std::vector* args) { 11 | vec3_t* pos = g_Data.getLocalPlayer()->getPos(); 12 | float yPos = pos->y - 1.62f; 13 | clientMessageF("[Packet] %sX: %.2f Y: %.2f Z: %.2f", GREEN, pos->x, yPos /* eye height */, pos->z); 14 | return true; 15 | } 16 | -------------------------------------------------------------------------------- /Packet/Command/Commands/CoordsCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | class CoordsCommand : public IMCCommand { 4 | public: 5 | CoordsCommand(); 6 | ~CoordsCommand(); 7 | 8 | // Inherited via IMCCommand 9 | virtual bool execute(std::vector* args) override; 10 | }; 11 | -------------------------------------------------------------------------------- /Packet/Command/Commands/CreditCommand.cpp: -------------------------------------------------------------------------------- 1 | #include "../../../Utils/Utils.h" 2 | #include "CreditCommand.h" 3 | 4 | CreditCommand::CreditCommand() : IMCCommand("credits", "Credits", "") { 5 | registerAlias("credit"); 6 | } 7 | 8 | CreditCommand::~CreditCommand() { 9 | } 10 | 11 | bool CreditCommand::execute(std::vector* args) { 12 | clientMessageF("-------------------"); 13 | clientMessageF("%sPacket Client Credits:", GRAY); 14 | clientMessageF("%sTurakan: Original (Unused) TargetHUD & LowHop", WHITE); 15 | clientMessageF("%sNRG: Kit command & ForceTotem", WHITE); 16 | //clientMessageF("%sLittle Kow: TargetStrafe and other stuff", WHITE); 17 | clientMessageF("-------------------"); 18 | return true; 19 | } -------------------------------------------------------------------------------- /Packet/Command/Commands/CreditCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | class CreditCommand : public IMCCommand { 4 | public: 5 | CreditCommand(); 6 | ~CreditCommand(); 7 | 8 | // Inherited via IMCCommand 9 | virtual bool execute(std::vector* args) override; 10 | }; -------------------------------------------------------------------------------- /Packet/Command/Commands/DamageCommand.cpp: -------------------------------------------------------------------------------- 1 | #include "DamageCommand.h" 2 | 3 | #include "../../Module/ModuleManager.h" 4 | 5 | DamageCommand::DamageCommand() : IMCCommand("damage", "Damage yourself (relies on falldamage)", "") { 6 | registerAlias("dmg"); 7 | } 8 | 9 | DamageCommand::~DamageCommand() { 10 | } -------------------------------------------------------------------------------- /Packet/Command/Commands/DamageCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | class DamageCommand : public IMCCommand { 4 | public: 5 | DamageCommand(); 6 | ~DamageCommand(); 7 | 8 | }; 9 | -------------------------------------------------------------------------------- /Packet/Command/Commands/DupeCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | 4 | class DupeCommand : public IMCCommand { 5 | public: 6 | DupeCommand(); 7 | ~DupeCommand(); 8 | 9 | // Inherited via IMCCommand 10 | virtual bool execute(std::vector* args) override; 11 | }; 12 | -------------------------------------------------------------------------------- /Packet/Command/Commands/EjectCommand.cpp: -------------------------------------------------------------------------------- 1 | #include "EjectCommand.h" 2 | 3 | EjectCommand::EjectCommand() : IMCCommand("eject", "Removes the cheat from the game.", "") { 4 | registerAlias("uninject"); 5 | } 6 | 7 | EjectCommand::~EjectCommand() { 8 | } 9 | 10 | bool EjectCommand::execute(std::vector* args) { 11 | GameData::terminate(); 12 | return true; 13 | } 14 | -------------------------------------------------------------------------------- /Packet/Command/Commands/EjectCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | class EjectCommand : public IMCCommand { 4 | public: 5 | EjectCommand(); 6 | ~EjectCommand(); 7 | 8 | // Inherited via IMCCommand 9 | virtual bool execute(std::vector* args) override; 10 | }; 11 | -------------------------------------------------------------------------------- /Packet/Command/Commands/EnchantCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | class EnchantCommand : public IMCCommand { 4 | private: 5 | std::map enchantMap; 6 | 7 | public: 8 | EnchantCommand(); 9 | ~EnchantCommand(); 10 | 11 | // Inherited via IMCCommand 12 | virtual bool execute(std::vector* args) override; 13 | }; -------------------------------------------------------------------------------- /Packet/Command/Commands/ExecuteCommand.cpp: -------------------------------------------------------------------------------- 1 | #include "ExecuteCommand.h" 2 | 3 | ExecuteCommand::ExecuteCommand() : IMCCommand("execute", "Executes javascript code", "") { 4 | registerAlias("exec"); 5 | } 6 | 7 | ExecuteCommand::~ExecuteCommand() { 8 | } 9 | 10 | bool ExecuteCommand::execute(std::vector* args) { 11 | assertTrue(args->size() > 1); 12 | std::ostringstream os; 13 | for (int i = 1; i < args->size(); i++) { 14 | if (i > 1) 15 | os << " "; 16 | os << args->at(i); 17 | } 18 | auto str = os.str(); 19 | 20 | auto wstr = Utils::stringToWstring(str); 21 | clientMessageF("[Packet] %sScript returned: %s%S", GRAY, WHITE, scriptMgr.runScript(wstr).c_str()); 22 | return true; 23 | } 24 | -------------------------------------------------------------------------------- /Packet/Command/Commands/ExecuteCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "ICommand.h" 4 | 5 | #include "../../Scripting/ScriptManager.h" 6 | 7 | class ExecuteCommand : public IMCCommand { 8 | public: 9 | ExecuteCommand(); 10 | ~ExecuteCommand(); 11 | 12 | // Inherited via IMCCommand 13 | virtual bool execute(std::vector* args) override; 14 | }; 15 | -------------------------------------------------------------------------------- /Packet/Command/Commands/FriendListCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | class FriendListCommand : public IMCCommand { 4 | public: 5 | FriendListCommand(); 6 | ~FriendListCommand(); 7 | 8 | static void addFriend(C_Entity* currentEntity, bool); 9 | static std::vector* globalarg; 10 | 11 | // Inherited via IMCCommand 12 | virtual bool execute(std::vector* args) override; 13 | }; 14 | -------------------------------------------------------------------------------- /Packet/Command/Commands/GameModeCommand.cpp: -------------------------------------------------------------------------------- 1 | #include "GameModeCommand.h" 2 | 3 | GameModeCommand::GameModeCommand() : IMCCommand("gamemode", "Changes the local player's gamemode", "") { 4 | registerAlias("gm"); 5 | } 6 | 7 | GameModeCommand::~GameModeCommand() { 8 | } 9 | 10 | bool GameModeCommand::execute(std::vector* args) { 11 | assertTrue(g_Data.getLocalPlayer() != nullptr); 12 | assertTrue(args->size() > 1); 13 | int gamemode = assertInt(args->at(1)); 14 | if (gamemode >= 0 && gamemode <= 2) { 15 | g_Data.getLocalPlayer()->setGameModeType(gamemode); 16 | clientMessageF("[Packet] %sGameMode changed!", GREEN); 17 | return true; 18 | } 19 | 20 | clientMessageF("[Packet] %sInvalid GameMode!", RED); 21 | return true; 22 | } 23 | -------------------------------------------------------------------------------- /Packet/Command/Commands/GameModeCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | class GameModeCommand : public IMCCommand { 4 | public: 5 | GameModeCommand(); 6 | ~GameModeCommand(); 7 | 8 | // Inherited via IMCCommand 9 | virtual bool execute(std::vector* args) override; 10 | }; 11 | -------------------------------------------------------------------------------- /Packet/Command/Commands/GiveCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | class GiveCommand : public IMCCommand { 4 | public: 5 | GiveCommand(); 6 | ~GiveCommand(); 7 | 8 | // Inherited via IMCCommand 9 | virtual bool execute(std::vector* args) override; 10 | }; 11 | -------------------------------------------------------------------------------- /Packet/Command/Commands/HelpCommand.cpp: -------------------------------------------------------------------------------- 1 | #include "HelpCommand.h" 2 | 3 | #include "../CommandMgr.h" 4 | 5 | HelpCommand::HelpCommand() : IMCCommand("commands", "Lists all commands", "") { 6 | registerAlias("command"); 7 | registerAlias("help"); //who tf would call this commands what ---- it lists the commands? 8 | } 9 | 10 | HelpCommand::~HelpCommand() { 11 | } 12 | 13 | bool HelpCommand::execute(std::vector* args) { 14 | std::vector* commandList = cmdMgr->getCommandList(); 15 | for (auto it = commandList->begin(); it != commandList->end(); ++it) { 16 | IMCCommand* plump = *it; 17 | clientMessageF("%s%s - %s", plump->getCommand(), GRAY, plump->getDescription()); 18 | } 19 | return true; 20 | } -------------------------------------------------------------------------------- /Packet/Command/Commands/HelpCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | class HelpCommand : public IMCCommand { 4 | public: 5 | HelpCommand(); 6 | ~HelpCommand(); 7 | 8 | // Inherited via IMCCommand 9 | virtual bool execute(std::vector* args) override; 10 | }; 11 | -------------------------------------------------------------------------------- /Packet/Command/Commands/HideCommand.cpp: -------------------------------------------------------------------------------- 1 | #include "HideCommand.h" 2 | 3 | HideCommand::HideCommand() : IMCCommand("hide", "hide the mod", "") { 4 | } 5 | 6 | HideCommand::~HideCommand() { 7 | } 8 | 9 | bool HideCommand::execute(std::vector* args) { 10 | GameData::hide(); 11 | if (GameData::shouldHide()) { 12 | clientMessageF("[Packet] %sHidden.", GREEN); 13 | } else { 14 | clientMessageF("[Packet] %sClient is now visible.", GREEN); 15 | } 16 | return true; 17 | } -------------------------------------------------------------------------------- /Packet/Command/Commands/HideCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | class HideCommand : public IMCCommand { 4 | public: 5 | HideCommand(); 6 | ~HideCommand(); 7 | 8 | // Inherited via IMCCommand 9 | virtual bool execute(std::vector* args) override; 10 | }; 11 | -------------------------------------------------------------------------------- /Packet/Command/Commands/ICommand.cpp: -------------------------------------------------------------------------------- 1 | #include "ICommand.h" 2 | #include 3 | #include 4 | #include 5 | 6 | IMCCommand::IMCCommand(const char* command, const char* description, const char* usage) { 7 | this->_command = command; 8 | this->_description = description; 9 | this->_usage = usage; 10 | registerAlias(command); 11 | } 12 | 13 | IMCCommand::~IMCCommand() { 14 | } 15 | void IMCCommand::clientMessageF(const char* fmt, ...) { 16 | va_list arg; 17 | va_start(arg, fmt); 18 | g_Data.getGuiData()->displayClientMessageVA(fmt, arg); 19 | va_end(arg); 20 | } 21 | void IMCCommand::registerAlias(const char* str) { 22 | std::string ss = str; 23 | std::transform(ss.begin(), ss.end(), ss.begin(), ::tolower); 24 | aliasList.push_back(ss); 25 | } 26 | -------------------------------------------------------------------------------- /Packet/Command/Commands/IDCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | class IDCommand : public IMCCommand { 4 | public: 5 | IDCommand(); 6 | ~IDCommand(); 7 | 8 | // Inherited via IMCCommand 9 | virtual bool execute(std::vector* args) override; 10 | }; 11 | -------------------------------------------------------------------------------- /Packet/Command/Commands/KitCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | 4 | class KitCommand : public IMCCommand { 5 | public: 6 | KitCommand(); 7 | ~KitCommand(); 8 | 9 | // Inherited via IMCCommand 10 | virtual bool execute(std::vector* args) override; 11 | }; -------------------------------------------------------------------------------- /Packet/Command/Commands/ModulesCommand.cpp: -------------------------------------------------------------------------------- 1 | #include "ModulesCommand.h" 2 | 3 | #include 4 | #include "../../Module/ModuleManager.h" 5 | 6 | ModulesCommand::ModulesCommand() : IMCCommand("modules", "Lists all modules", "") { 7 | registerAlias("mods"); 8 | } 9 | 10 | ModulesCommand::~ModulesCommand() { 11 | } 12 | 13 | bool ModulesCommand::execute(std::vector* args) { 14 | auto lock = moduleMgr->lockModuleList(); 15 | std::vector>* modules = moduleMgr->getModuleList(); 16 | clientMessageF("=========="); 17 | clientMessageF("Modules (%i):", modules->size()); 18 | for (auto it = modules->begin(); it != modules->end(); ++it) { 19 | auto mod = *it; 20 | clientMessageF("%s %s- %s%s", mod->getModuleName(), GRAY, ITALIC, mod->getTooltip()); 21 | } 22 | 23 | return true; 24 | } 25 | -------------------------------------------------------------------------------- /Packet/Command/Commands/ModulesCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | class ModulesCommand : public IMCCommand { 4 | public: 5 | ModulesCommand(); 6 | ~ModulesCommand(); 7 | 8 | // Inherited via IMCCommand 9 | virtual bool execute(std::vector* args) override; 10 | }; 11 | -------------------------------------------------------------------------------- /Packet/Command/Commands/NameSpoofCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | #include 4 | 5 | class NameSpoofCommand : public IMCCommand { 6 | public: 7 | NameSpoofCommand(); 8 | ~NameSpoofCommand(); 9 | 10 | // Inherited via IMCCommand 11 | virtual bool execute(std::vector* args) override; 12 | }; 13 | -------------------------------------------------------------------------------- /Packet/Command/Commands/NbtCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | 4 | class NbtCommand : public IMCCommand { 5 | public: 6 | NbtCommand(); 7 | ~NbtCommand(); 8 | 9 | // Inherited via IMCCommand 10 | virtual bool execute(std::vector* args) override; 11 | const char* getUsage(const char* alias) override; 12 | }; 13 | -------------------------------------------------------------------------------- /Packet/Command/Commands/PanicCommand.cpp: -------------------------------------------------------------------------------- 1 | #include "PanicCommand.h" 2 | 3 | #include "../../Module/ModuleManager.h" 4 | 5 | PanicCommand::PanicCommand() : IMCCommand("panic", "Disables all Modules", "") { 6 | } 7 | 8 | PanicCommand::~PanicCommand() { 9 | } 10 | 11 | bool PanicCommand::execute(std::vector* args) { 12 | auto lock = moduleMgr->lockModuleList(); 13 | std::vector> * modules = moduleMgr->getModuleList(); 14 | 15 | for (auto it = modules->begin(); it != modules->end(); ++it) { 16 | auto mod = *it; 17 | mod->setEnabled(false); 18 | } 19 | clientMessageF("%sDisabled all Modules!", GREEN); 20 | return true; 21 | } 22 | -------------------------------------------------------------------------------- /Packet/Command/Commands/PanicCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | class PanicCommand : public IMCCommand { 4 | public: 5 | PanicCommand(); 6 | ~PanicCommand(); 7 | 8 | // Inherited via IMCCommand 9 | virtual bool execute(std::vector* args) override; 10 | }; 11 | -------------------------------------------------------------------------------- /Packet/Command/Commands/PartyCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | class PartyCommand : public IMCCommand { 4 | public: 5 | PartyCommand(); 6 | ~PartyCommand(); 7 | 8 | // Inherited via IMCCommand 9 | virtual bool execute(std::vector* args) override; 10 | }; -------------------------------------------------------------------------------- /Packet/Command/Commands/PlayerTeleportCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | class PlayerTeleportCommand : public IMCCommand { 4 | public: 5 | PlayerTeleportCommand(); 6 | ~PlayerTeleportCommand(); 7 | 8 | // Inherited via IMCCommand 9 | virtual bool execute(std::vector* args) override; 10 | }; 11 | -------------------------------------------------------------------------------- /Packet/Command/Commands/RelativeTeleportCommand.cpp: -------------------------------------------------------------------------------- 1 | #include "RelativeTeleportCommand.h" 2 | 3 | RelativeTeleportCommand::RelativeTeleportCommand() : IMCCommand("vclip", "Teleports to coordinates relative to the Player", " ") { 4 | registerAlias("v clip"); 5 | } 6 | 7 | RelativeTeleportCommand::~RelativeTeleportCommand() { 8 | } 9 | 10 | bool RelativeTeleportCommand::execute(std::vector* args) { 11 | assertTrue(g_Data.getLocalPlayer() != nullptr); 12 | assertTrue(args->size() >= 4); 13 | 14 | vec3_t pPos = g_Data.getLocalPlayer()->eyePos0; 15 | 16 | vec3_t pos; 17 | pos.y = assertFloat(args->at(2)) + pPos.y; 18 | 19 | g_Data.getLocalPlayer()->setPos(pos); 20 | clientMessageF("%sTeleported!", GREEN); 21 | return true; 22 | } -------------------------------------------------------------------------------- /Packet/Command/Commands/RelativeTeleportCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | class RelativeTeleportCommand : public IMCCommand { 4 | public: 5 | RelativeTeleportCommand(); 6 | ~RelativeTeleportCommand(); 7 | 8 | // Inherited via IMCCommand 9 | virtual bool execute(std::vector* args) override; 10 | }; 11 | -------------------------------------------------------------------------------- /Packet/Command/Commands/SayCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | #include 4 | class SayCommand : public IMCCommand { 5 | public: 6 | SayCommand(); 7 | ~SayCommand(); 8 | 9 | // Inherited via IMCCommand 10 | virtual bool execute(std::vector* args) override; 11 | }; 12 | -------------------------------------------------------------------------------- /Packet/Command/Commands/ScriptCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../../Scripting/ScriptManager.h" 3 | #include "ICommand.h" 4 | 5 | class ScriptCommand : public IMCCommand { 6 | public: 7 | ScriptCommand(); 8 | ~ScriptCommand(); 9 | 10 | virtual bool execute(std::vector* args) override; 11 | }; 12 | -------------------------------------------------------------------------------- /Packet/Command/Commands/ServerCommand.cpp: -------------------------------------------------------------------------------- 1 | #include "ServerCommand.h" 2 | 3 | ServerCommand::ServerCommand() : IMCCommand("server", "Show information about the server you're playing on", "") { 4 | registerAlias("ip"); 5 | } 6 | 7 | ServerCommand::~ServerCommand() { 8 | } 9 | 10 | bool ServerCommand::execute(std::vector* args) { 11 | assertTrue(g_Data.getLocalPlayer() != nullptr); 12 | 13 | if (g_Data.getRakNetInstance()->isonaServer()) 14 | clientMessageF("[Packet] You're currently playing on:\nIP: %s\nPort: %s", g_Data.getRakNetInstance()->serverIp.getText(), std::to_string(g_Data.getRakNetInstance()->serverPort).c_str()); 15 | else 16 | clientMessageF("[Packet] %sYou're not playing on a server.", RED); 17 | return true; 18 | } 19 | -------------------------------------------------------------------------------- /Packet/Command/Commands/ServerCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | 4 | class ServerCommand : public IMCCommand { 5 | public: 6 | ServerCommand(); 7 | ~ServerCommand(); 8 | 9 | // Inherited via IMCCommand 10 | virtual bool execute(std::vector* args) override; 11 | }; 12 | -------------------------------------------------------------------------------- /Packet/Command/Commands/SetprefixCommand.cpp: -------------------------------------------------------------------------------- 1 | #include "SetprefixCommand.h" 2 | 3 | SetprefixCommand::SetprefixCommand() : IMCCommand("setprefix", "Set the prefix for commands", "") { 4 | registerAlias("prefix"); 5 | } 6 | 7 | SetprefixCommand::~SetprefixCommand() { 8 | } 9 | 10 | bool SetprefixCommand::execute(std::vector* args) { 11 | assertTrue(args->size() > 1); 12 | assertTrue(args->at(1).length() == 1); 13 | char prefix = args->at(1).at(0); 14 | cmdMgr->prefix = prefix; 15 | clientMessageF("[Packet] %sSet prefix to %s%c", GREEN, GRAY, prefix); 16 | return true; 17 | } -------------------------------------------------------------------------------- /Packet/Command/Commands/SetprefixCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../CommandMgr.h" 3 | 4 | #include "ICommand.h" 5 | class SetprefixCommand : public IMCCommand { 6 | public: 7 | SetprefixCommand(); 8 | ~SetprefixCommand(); 9 | 10 | // Inherited via IMCCommand 11 | virtual bool execute(std::vector* args) override; 12 | }; 13 | -------------------------------------------------------------------------------- /Packet/Command/Commands/SpammerCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | #include "ICommand.h" 5 | 6 | class SpammerCommand : public IMCCommand { 7 | public: 8 | SpammerCommand(); 9 | ~SpammerCommand(); 10 | 11 | // Inherited via IMCCommand 12 | virtual bool execute(std::vector* args) override; 13 | }; -------------------------------------------------------------------------------- /Packet/Command/Commands/TeleportCommand.cpp: -------------------------------------------------------------------------------- 1 | #include "TeleportCommand.h" 2 | 3 | TeleportCommand::TeleportCommand() : IMCCommand("tp", "Teleports to coordinates", " ") { 4 | registerAlias("teleport"); 5 | registerAlias("setpos"); 6 | } 7 | 8 | TeleportCommand::~TeleportCommand() { 9 | } 10 | 11 | bool TeleportCommand::execute(std::vector* args) { 12 | assertTrue(g_Data.getLocalPlayer() != nullptr); 13 | assertTrue(args->size() >= 4); 14 | 15 | vec3_t pos; 16 | pos.x = assertFloat(args->at(1)); 17 | pos.y = assertFloat(args->at(2)); 18 | pos.z = assertFloat(args->at(3)); 19 | 20 | g_Data.getLocalPlayer()->setPos(pos); 21 | clientMessageF("[Packet] %sTeleported!", GREEN); 22 | return true; 23 | } -------------------------------------------------------------------------------- /Packet/Command/Commands/TeleportCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | class TeleportCommand : public IMCCommand { 4 | public: 5 | TeleportCommand(); 6 | ~TeleportCommand(); 7 | 8 | // Inherited via IMCCommand 9 | virtual bool execute(std::vector* args) override; 10 | }; 11 | -------------------------------------------------------------------------------- /Packet/Command/Commands/TestCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | 4 | class TestCommand : public IMCCommand { 5 | public: 6 | TestCommand(); 7 | ~TestCommand(); 8 | 9 | // Inherited via IMCCommand 10 | virtual bool execute(std::vector* args) override; 11 | }; 12 | -------------------------------------------------------------------------------- /Packet/Command/Commands/ToggleCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | class ToggleCommand : public IMCCommand { 4 | public: 5 | ToggleCommand(); 6 | ~ToggleCommand(); 7 | 8 | // Inherited via IMCCommand 9 | virtual bool execute(std::vector* args) override; 10 | }; 11 | -------------------------------------------------------------------------------- /Packet/Command/Commands/TopCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "ICommand.h" 3 | class TopCommand : public IMCCommand { 4 | public: 5 | TopCommand(); 6 | ~TopCommand(); 7 | 8 | virtual bool execute(std::vector* args) override; 9 | }; -------------------------------------------------------------------------------- /Packet/Command/Commands/UnbindCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | #include "ICommand.h" 5 | 6 | class UnbindCommand : public IMCCommand { 7 | public: 8 | UnbindCommand(); 9 | ~UnbindCommand(); 10 | 11 | // Inherited via IMCCommand 12 | virtual bool execute(std::vector* args) override; 13 | }; 14 | -------------------------------------------------------------------------------- /Packet/Command/Commands/WatermarkCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | #include "ICommand.h" 5 | 6 | class WatermarkCommand : public IMCCommand { 7 | public: 8 | WatermarkCommand(); 9 | ~WatermarkCommand(); 10 | 11 | // Inherited via IMCCommand 12 | virtual bool execute(std::vector* args) override; 13 | }; -------------------------------------------------------------------------------- /Packet/Command/Commands/WaypointCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "ICommand.h" 4 | #include "../../Module/ModuleManager.h" 5 | #include "../../Module/Modules/Waypoints.h" 6 | 7 | class WaypointCommand : public IMCCommand { 8 | public: 9 | WaypointCommand(); 10 | ~WaypointCommand(); 11 | 12 | // Inherited via IMCCommand 13 | virtual bool execute(std::vector* args) override; 14 | }; 15 | -------------------------------------------------------------------------------- /Packet/Command/Commands/desktop.ini: -------------------------------------------------------------------------------- 1 | [LocalizedFileNames] 2 | SpammerCommand.cpp=@SpammerCommand.cpp,0 3 | Spammer.h=@Spammer.h,0 4 | -------------------------------------------------------------------------------- /Packet/Command/Commands/setoffhandCommand.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include "ICommand.h" 6 | 7 | class setoffhandCommand : public IMCCommand { 8 | public: 9 | setoffhandCommand(); 10 | ~setoffhandCommand(); 11 | 12 | // Inherited via IMCCommand 13 | virtual bool execute(std::vector* args) override; 14 | }; 15 | -------------------------------------------------------------------------------- /Packet/Config/AccountInformation.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | 4 | #include 5 | 6 | class AccountInformation { 7 | private: 8 | bool isGuest; 9 | bool didVerify = false; // Did check if its verified? 10 | bool isValid = false; // Is it a verified account 11 | std::string name; 12 | std::string authToken; 13 | unsigned int serialNum = 0; 14 | 15 | AccountInformation(std::string, unsigned int); 16 | AccountInformation(); 17 | 18 | public: 19 | bool verify(); 20 | 21 | static AccountInformation fromToken(std::string authToken, unsigned int serial); 22 | static AccountInformation asGuest(); 23 | }; 24 | -------------------------------------------------------------------------------- /Packet/Config/ConfigManager.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #ifndef WIN32_LEAN_AND_MEAN 4 | #define WIN32_LEAN_AND_MEAN 5 | #endif 6 | #include 7 | 8 | #include 9 | #include 10 | #include 11 | #pragma comment(lib, "runtimeobject") 12 | 13 | #include "../../Utils/Json.hpp" 14 | #include "../Command/CommandMgr.h" 15 | #include "../Module/ModuleManager.h" 16 | 17 | using json = nlohmann::json; 18 | 19 | class ConfigManager { 20 | private: 21 | std::wstring roamingFolder; 22 | static std::wstring GetRoamingFolderPath(); 23 | json currentConfigObj; 24 | 25 | public: 26 | ConfigManager(); 27 | ~ConfigManager(); 28 | 29 | #ifdef _DEBUG 30 | std::string currentConfig = "PCBeta"; 31 | 32 | #else 33 | std::string currentConfig = "PCPublic"; 34 | #endif 35 | 36 | void loadConfig(std::string name, bool create); 37 | void saveConfig(); 38 | void init(); 39 | }; 40 | 41 | extern ConfigManager* configMgr; 42 | -------------------------------------------------------------------------------- /Packet/FriendList/FriendList.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #include "../../Memory/GameData.h" 9 | 10 | class FriendList { 11 | private: 12 | //GameData* gameData; 13 | std::vector List; 14 | 15 | public: 16 | FriendList(); 17 | ~FriendList(); 18 | 19 | static std::vector getList(); 20 | static bool findPlayer(std::string Name); 21 | static void addPlayerToList(std::string name); 22 | static bool removePlayer(std::string& g); 23 | }; 24 | 25 | extern FriendList g_friend; 26 | -------------------------------------------------------------------------------- /Packet/GuiUtils.cpp: -------------------------------------------------------------------------------- 1 | #include "GuiUtils.h" 2 | 3 | void GuiUtils::drawCrossLine(vec2_t pos, MC_Color col, float lineWidth, float crossSize, bool secondCross) { 4 | crossSize /= 2; 5 | DrawUtils::setColor(col.r, col.g, col.b, col.a); 6 | //float MidX = (pos.z + pos.x) / 2; 7 | //float MidY = (pos.y + pos.w) / 2; 8 | DrawUtils::drawLine(vec2_t(pos.x - crossSize, pos.y), vec2_t(pos.x + crossSize, pos.y), lineWidth); 9 | if (secondCross) 10 | DrawUtils::drawLine(vec2_t(pos.x, pos.y - crossSize), vec2_t(pos.x, pos.y + crossSize), lineWidth); 11 | } 12 | -------------------------------------------------------------------------------- /Packet/GuiUtils.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "DrawUtils.h" 3 | 4 | class GuiUtils { 5 | public: 6 | static void drawCrossLine(vec2_t pos, MC_Color col, float lineWidth, float crossSize, bool secondCross); 7 | }; 8 | -------------------------------------------------------------------------------- /Packet/Loader.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../Utils/Logger.h" 4 | 5 | #ifndef WIN32_LEAN_AND_MEAN 6 | #define WIN32_LEAN_AND_MEAN 7 | #endif 8 | #include 9 | 10 | #include 11 | #include 12 | #include 13 | 14 | #include "../Memory/GameData.h" 15 | #include "../Memory/Hooks.h" 16 | #include "../Memory/MinHook.h" 17 | #include "../SDK/CChestBlockActor.h" 18 | #include "../SDK/CClientInstance.h" 19 | #include "../SDK/CClientInstanceScreenModel.h" 20 | #include "../SDK/CEntity.h" 21 | #include "../SDK/CGameMode.h" 22 | #include "../SDK/CPacket.h" 23 | #include "../Utils/HMath.h" 24 | #include "../Utils/Target.h" 25 | #include "../Utils/TextFormat.h" 26 | #include "../Utils/Utils.h" 27 | #include "../include/WinHttpClient.h" 28 | #include "Command/CommandMgr.h" 29 | #include "Config/ConfigManager.h" 30 | #include "Menu/ClickGui.h" 31 | #include "Menu/TabGui.h" 32 | #include "Module/ModuleManager.h" 33 | #include "ImmediateGui.h" 34 | -------------------------------------------------------------------------------- /Packet/Menu/HudEditor.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | #include "../../Memory/GameData.h" 7 | #include "../DrawUtils.h" 8 | #include "../GuiUtils.h" 9 | #include "../Module/ModuleManager.h" 10 | 11 | struct HudWindow { 12 | HudWindow() { 13 | pos.x = 0; 14 | pos.y = 0; 15 | 16 | size.x = 30; 17 | size.y = 30; 18 | } 19 | vec2_t pos; 20 | vec2_t size; 21 | }; 22 | 23 | class HudEditor { 24 | public: 25 | static void init(); 26 | static void render(); 27 | static void onKeyUpdate(int key, bool isDown); 28 | static void onMouseClickUpdate(int key, bool isDown); 29 | static void onWheelScroll(bool direction); // true = up, false = down 30 | //static void onLoadConfig(void* confVoid); 31 | //static void onSaveConfig(void* confVoid); 32 | }; 33 | -------------------------------------------------------------------------------- /Packet/Menu/TabGui.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include "../DrawUtils.h" 6 | #include "../Module/ModuleManager.h" 7 | 8 | class TabGui { 9 | private: 10 | static void renderLabel(const char* text, std::shared_ptr mod = 0); 11 | static void renderLevel(); 12 | 13 | public: 14 | static void init(); 15 | static void render(); 16 | static void onKeyUpdate(int key, bool isDown); 17 | }; 18 | -------------------------------------------------------------------------------- /Packet/Module/Modules/Aimbot.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../ModuleManager.h" 3 | #include "Module.h" 4 | 5 | class Aimbot : public IModule { 6 | private: 7 | bool vertical = true; 8 | bool sword = false; 9 | bool click = true; 10 | float speedAm = 90.f; 11 | //float verticalspeed = 90.f; 12 | float rangeAm = 180.f; 13 | //float horizontalrange = 180.f; 14 | 15 | public: 16 | bool lock = false; 17 | float range = 8; 18 | Aimbot(); 19 | ~Aimbot(); 20 | 21 | // Inherited via IModule 22 | virtual const char* getModuleName() override; 23 | virtual void onPostRender(C_MinecraftUIRenderContext* renderCtx) override; 24 | }; 25 | -------------------------------------------------------------------------------- /Packet/Module/Modules/Animations.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../ModuleManager.h" 3 | #include "Module.h" 4 | class Animations : public IModule { 5 | private: 6 | bool reset = false; 7 | int delay = 0; 8 | 9 | public: 10 | bool rightClickDown = false; 11 | bool doTranslate = true; 12 | bool aroundWorld = false; 13 | bool doScale = true; 14 | bool doRotate = false; 15 | 16 | float float1 = 0; 17 | float xMod = 1.f; 18 | float yMod = 1.f; 19 | float zMod = 1.f; 20 | 21 | float xTrans = 0.f; 22 | float yTrans = 0.f; 23 | float zTrans = 0.f; 24 | 25 | float xRotate = 0.f; 26 | float yRotate = 0.f; 27 | float zRotate = 0.f; 28 | Animations(); 29 | ~Animations(); 30 | 31 | std::string name = "Animations"; 32 | SettingEnum mode = this; 33 | 34 | 35 | // Inherited via IModule 36 | virtual const char* getModuleName() override; 37 | virtual void onTick(C_GameMode* gm) override; 38 | virtual const char* getRawModuleName() override; 39 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/AntiImmobile.cpp: -------------------------------------------------------------------------------- 1 | #include "AntiImmobile.h" 2 | 3 | AntiImmobile::AntiImmobile() : IModule(0, Category::EXPLOIT, "Disables immobile flag set by hive servers to prevent you from moving") { 4 | } 5 | AntiImmobile::~AntiImmobile() { 6 | } 7 | 8 | const char* AntiImmobile::getModuleName() { 9 | return "AntiImmobile"; 10 | } -------------------------------------------------------------------------------- /Packet/Module/Modules/AntiImmobile.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | 4 | class AntiImmobile : public IModule { 5 | public: 6 | AntiImmobile(); 7 | ~AntiImmobile(); 8 | 9 | const char* getModuleName() override; 10 | }; 11 | -------------------------------------------------------------------------------- /Packet/Module/Modules/AntiVoid.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "..\ModuleManager.h" 3 | #include "Module.h" 4 | 5 | class AntiVoid : public IModule { 6 | private: 7 | std::vector below; 8 | bool foundVoid = false; 9 | bool voidCheck = true; 10 | int distance = 5; 11 | vec3_t savedPos; 12 | int tick = 0; 13 | 14 | public: 15 | bool blink = false; 16 | 17 | AntiVoid(); 18 | ~AntiVoid(); 19 | 20 | C_MoveInputHandler* inputHandler = nullptr; 21 | SettingEnum mode = this; 22 | 23 | // Inherited via IModule 24 | virtual void onEnable() override; 25 | virtual void onDisable() override; 26 | virtual const char* getModuleName() override; 27 | virtual void onTick(C_GameMode* gm) override; 28 | }; 29 | -------------------------------------------------------------------------------- /Packet/Module/Modules/ArrayList.cpp: -------------------------------------------------------------------------------- 1 | #include "ArrayList.h" 2 | 3 | #include "../../DrawUtils.h" 4 | #include "../../Scripting/ScriptManager.h" 5 | 6 | ArrayList::ArrayList() : IModule(0, Category::VISUAL, "Displays ArrayList") { 7 | registerEnumSetting("Mode", &mode, 0); 8 | mode.addEntry("Outline", 0); 9 | mode.addEntry("Split", 1); 10 | mode.addEntry("Bar", 2); 11 | //mode.addEntry("Old", 3); 12 | mode.addEntry("None", 4); 13 | registerBoolSetting("Modes", &modes, modes); 14 | registerFloatSetting("Opacity", &bgOp, bgOp, 0.f, 1.f); 15 | } 16 | 17 | ArrayList::~ArrayList() { 18 | } 19 | 20 | const char* ArrayList::getModuleName() { 21 | return ("ArrayList"); 22 | } -------------------------------------------------------------------------------- /Packet/Module/Modules/ArrayList.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | 4 | class ArrayList : public IModule { 5 | public: 6 | ArrayList(); 7 | ~ArrayList(); 8 | 9 | bool modes = true; 10 | bool arraylist = true; 11 | bool arraylistBackground = true; 12 | float bgOp = 0.6; 13 | bool clickToggle = false; 14 | bool keybinds = false; 15 | bool alwaysShow = false; 16 | 17 | float scale = 1.f; 18 | 19 | SettingEnum mode = this; 20 | 21 | // Inherited via IModule 22 | virtual const char* getModuleName() override; 23 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/AutoArmor.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class AutoArmor : public IModule { 4 | public: 5 | C_CraftingScreenController* inventoryScreen = nullptr; 6 | AutoArmor(); 7 | ~AutoArmor(); 8 | 9 | virtual void onTick(C_GameMode* gm) override; 10 | virtual const char* getModuleName() override; 11 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/AutoClicker.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | #include "../ModuleManager.h" 4 | 5 | class AutoClicker : public IModule { 6 | private: 7 | int delay = 0; 8 | int Odelay = 0; 9 | bool weapons = false; 10 | bool breakBlocks = false; 11 | bool rightclick = false; 12 | bool hold = true; 13 | 14 | public: 15 | AutoClicker(); 16 | ~AutoClicker(); 17 | 18 | // Inherited via IModule 19 | virtual const char* getModuleName() override; 20 | virtual void onTick(C_GameMode* gm) override; 21 | }; 22 | -------------------------------------------------------------------------------- /Packet/Module/Modules/AutoTotem.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | 4 | class AutoTotem : public IModule { 5 | private: 6 | bool force = false; 7 | 8 | public: 9 | AutoTotem(); 10 | ~AutoTotem(); 11 | 12 | virtual const char* getModuleName() override; 13 | virtual void onTick(C_GameMode* gm) override; 14 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/BehindAura.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../../../Utils/Target.h" 3 | #include "../ModuleManager.h" 4 | #include "Module.h" 5 | 6 | class BehindAura : public IModule { 7 | private: 8 | float lerpSpeed = 1; 9 | float behindDist = 2.f; 10 | bool useLerp = true; 11 | bool usePos = false; 12 | bool useAttack = false; 13 | bool useTick = true; 14 | 15 | bool basicCheck = true; 16 | bool calcYawCheck = false; 17 | 18 | int delay = 0; 19 | int delay1 = 0; 20 | 21 | public: 22 | bool isMobAura = false; 23 | bool hurttime = false; 24 | float range = 6; 25 | 26 | BehindAura(); 27 | ~BehindAura(); 28 | 29 | // Inherited via IModule 30 | virtual const char* getModuleName() override; 31 | virtual void onTick(C_GameMode* gm) override; 32 | virtual void onEnable() override; 33 | virtual void onAttack(C_Entity* attackedEnt) override; 34 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/Blink.cpp: -------------------------------------------------------------------------------- 1 | #include "Blink.h" 2 | 3 | Blink::Blink() : IModule(0, Category::PLAYER, "Stops you from sending packets and then sends them in a bunch") { 4 | } 5 | 6 | Blink::~Blink() { 7 | this->getMovePlayerPacketHolder()->clear(); 8 | this->getPlayerAuthInputPacketHolder()->clear(); 9 | } 10 | 11 | const char* Blink::getModuleName() { 12 | return ("Blink"); 13 | } 14 | 15 | void Blink::onTick(C_GameMode* gm) { 16 | gm->player->fallDistance = 0.f; 17 | } -------------------------------------------------------------------------------- /Packet/Module/Modules/Blink.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class Blink : public IModule { 4 | private: 5 | std::vector MovePlayerPacketHolder; 6 | std::vector PlayerAuthInputPacketHolder; 7 | 8 | public: 9 | Blink(); 10 | ~Blink(); 11 | 12 | // Inherited via IModule 13 | virtual void onTick(C_GameMode* gm) override; 14 | virtual const char* getModuleName() override; 15 | 16 | inline std::vector* getMovePlayerPacketHolder() { return &MovePlayerPacketHolder; }; 17 | inline std::vector* getPlayerAuthInputPacketHolder() { return &PlayerAuthInputPacketHolder; }; 18 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/BlockESP.h: -------------------------------------------------------------------------------- 1 | 2 | #include "Module.h" 3 | class BlockESP : public IModule { 4 | public: 5 | bool spawner = false; 6 | bool dOre = false; 7 | bool eOre = false; 8 | bool rOre = false; 9 | bool gOre = false; 10 | bool iOre = false; 11 | bool cOre = false; 12 | float width = 0.5; 13 | int range = 5; 14 | 15 | BlockESP(); 16 | ~BlockESP(); 17 | 18 | // Inherited via IModule 19 | virtual const char* getModuleName() override; 20 | virtual void onPreRender(C_MinecraftUIRenderContext* renderCtx) override; 21 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/BlockOutline.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../ModuleManager.h" 3 | #include "Module.h" 4 | 5 | class BlockOutline : public IModule { 6 | public: 7 | bool rainbow = false; 8 | float width = 0.5; 9 | float red = 1; 10 | float green = 1; 11 | float blue = 1; 12 | 13 | SettingEnum mode = this; 14 | 15 | BlockOutline(); 16 | ~BlockOutline(); 17 | 18 | // Inherited via IModule 19 | virtual const char* getModuleName() override; 20 | virtual void onPostRender(C_MinecraftUIRenderContext* renderCtx) override; 21 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/BlockReach.cpp: -------------------------------------------------------------------------------- 1 | #include "BlockReach.h" 2 | 3 | BlockReach::BlockReach() : IModule(0, Category::PLAYER, "Gach.") { 4 | } 5 | 6 | BlockReach::~BlockReach() { 7 | } 8 | 9 | const char* BlockReach::getModuleName() { 10 | return "BlockReach"; 11 | } 12 | 13 | void BlockReach::onTick(C_GameMode* gm) { 14 | } -------------------------------------------------------------------------------- /Packet/Module/Modules/BlockReach.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class BlockReach : public IModule { 4 | public: 5 | BlockReach(); 6 | ~BlockReach(); 7 | 8 | // Inherited via IModule 9 | virtual const char* getModuleName() override; 10 | virtual void onTick(C_GameMode* gm) override; 11 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/BreadCrumbs.cpp: -------------------------------------------------------------------------------- 1 | #include "BreadCrumbs.h" 2 | 3 | BreadCrumbs::BreadCrumbs() : IModule(0, Category::VISUAL, "ezpssssz") { 4 | registerBoolSetting("Clear", &clear, clear); 5 | } 6 | 7 | BreadCrumbs::~BreadCrumbs() { 8 | } 9 | 10 | const char* BreadCrumbs::getModuleName() { 11 | return ("BreadCrumbs"); 12 | } 13 | 14 | void BreadCrumbs::onTick(C_GameMode* gm) { 15 | vec3_t eyePos = gm->player->eyePos0; 16 | eyePos.y = eyePos.y - 1.5; 17 | blockBelow.push_back(eyePos); 18 | if (clear) { 19 | blockBelow.clear(); 20 | clear = false; 21 | } 22 | } 23 | 24 | void BreadCrumbs::onLevelRender() { 25 | DrawUtils::setColor(1, 1, 1, 1); 26 | DrawUtils::drawLinestrip3d(blockBelow); 27 | } 28 | 29 | void BreadCrumbs::onDisable() { 30 | blockBelow.clear(); 31 | } -------------------------------------------------------------------------------- /Packet/Module/Modules/BreadCrumbs.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../DrawUtils.h" 4 | #include "Module.h" 5 | 6 | class BreadCrumbs : public IModule { 7 | public: 8 | std::vector blockBelow; 9 | bool clear = false; 10 | 11 | BreadCrumbs(); 12 | ~BreadCrumbs(); 13 | 14 | // Inherited via IModule 15 | virtual void onDisable() override; 16 | virtual void onLevelRender() override; 17 | virtual const char* getModuleName() override; 18 | virtual void onTick(C_GameMode* gm) override; 19 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/CameraMod.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Module.h" 4 | 5 | class CameraMod : public IModule { 6 | public: 7 | float* gammaPtr = nullptr; 8 | bool nohurtMode = false; 9 | bool fullbright = false; 10 | int fbAmount = 25; 11 | vec2_t rot; 12 | 13 | CameraMod(); 14 | // Inherited via IModule 15 | virtual const char* getModuleName() override; 16 | virtual void onTick(C_GameMode* gm) override; 17 | virtual void onEnable() override; 18 | virtual void onDisable() override; 19 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/ChatBypass.cpp: -------------------------------------------------------------------------------- 1 | #include "ChatBypass.h" 2 | 3 | ChatBypass::ChatBypass() : IModule(0, Category::MISC, "Description") { 4 | } 5 | 6 | const char* ChatBypass::getModuleName() { 7 | return "ChatBypass"; 8 | } -------------------------------------------------------------------------------- /Packet/Module/Modules/ChatBypass.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Module.h" 4 | 5 | class ChatBypass : public IModule { 6 | public: 7 | ChatBypass(); 8 | virtual const char* getModuleName(); 9 | }; 10 | #pragma once 11 | -------------------------------------------------------------------------------- /Packet/Module/Modules/ChestAura.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "..\ModuleManager.h" 3 | #include "Module.h" 4 | 5 | class ChestAura : public IModule { 6 | private: 7 | int range = 3; 8 | 9 | public: 10 | C_MoveInputHandler* inputHandler = nullptr; 11 | ChestAura(); 12 | ~ChestAura(); 13 | 14 | std::vector chestlist; 15 | 16 | // Inherited via IModule 17 | virtual const char* getModuleName() override; 18 | virtual void onTick(C_GameMode* gm) override; 19 | virtual void onDisable() override; 20 | }; 21 | -------------------------------------------------------------------------------- /Packet/Module/Modules/ChestESP.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Module.h" 4 | 5 | class ChestESP : public IModule { 6 | private: 7 | int tickTimeout = 0; 8 | std::vector> bufferedChestList; 9 | std::mutex listLock; 10 | 11 | public: 12 | ChestESP(); 13 | ~ChestESP(); 14 | 15 | // Inherited via IModule 16 | virtual const char* getModuleName() override; 17 | virtual void onPreRender(C_MinecraftUIRenderContext* renderCtx) override; 18 | virtual void onTick(C_GameMode* gm) override; 19 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/ChestStealer.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class ChestStealer : public IModule { 4 | private: 5 | bool enhanced = true; 6 | int Odelay = 0; 7 | int delay = 10; 8 | 9 | public: 10 | bool autoDisable = false; 11 | ChestStealer(); 12 | ~ChestStealer(); 13 | 14 | // Inherited via IModule 15 | virtual void chestScreenController_tick(C_ChestScreenController* c); 16 | virtual const char* getModuleName() override; 17 | }; 18 | -------------------------------------------------------------------------------- /Packet/Module/Modules/ClickTP.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../../DrawUtils.h" 3 | #include "Module.h" 4 | class ClickTP : public IModule { 5 | private: 6 | bool hasClicked = false; 7 | int timeWaited = 1; 8 | bool hand = true; 9 | vec3_t position; 10 | 11 | public: 12 | ClickTP(); 13 | ~ClickTP(); 14 | 15 | // Inherited via IModule 16 | virtual void onTick(C_GameMode* gm) override; 17 | virtual const char* getModuleName() override; 18 | virtual void onPostRender(C_MinecraftUIRenderContext* renderCtx) override; 19 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/Criticals.cpp: -------------------------------------------------------------------------------- 1 | #include "Criticals.h" 2 | 3 | Criticals::Criticals() : IModule(0, Category::COMBAT, "Each hit is a critical cancer hit") { 4 | } 5 | 6 | Criticals::~Criticals() { 7 | } 8 | 9 | const char* Criticals::getModuleName() { 10 | return ("Criticals"); 11 | } 12 | 13 | void Criticals::onSendPacket(C_Packet* packet) { 14 | if (packet->isInstanceOf() && g_Data.getLocalPlayer() != nullptr) { 15 | C_MovePlayerPacket* movePacket = reinterpret_cast(packet); 16 | movePacket->onGround = false; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Packet/Module/Modules/Criticals.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class Criticals : public IModule { 4 | public: 5 | Criticals(); 6 | ~Criticals(); 7 | 8 | // Inherited via IModule 9 | virtual const char* getModuleName() override; 10 | virtual void onSendPacket(C_Packet* packet) override; 11 | }; 12 | -------------------------------------------------------------------------------- /Packet/Module/Modules/CustomSky.cpp: -------------------------------------------------------------------------------- 1 | #include "CustomSky.h" 2 | 3 | CustomSky::CustomSky() : IModule(0, Category::VISUAL, "CustomSky") { 4 | registerBoolSetting("Rainbow", &rainbow, rainbow); 5 | registerFloatSetting("Red", &red, red, 0.f, 1.f); 6 | registerFloatSetting("Green", &green, green, 0.f, 1.f); 7 | registerFloatSetting("Blue", &blue, blue, 0.f, 1.f); 8 | } 9 | 10 | const char* CustomSky::getModuleName() { 11 | return "CustomSky"; 12 | } -------------------------------------------------------------------------------- /Packet/Module/Modules/CustomSky.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Module.h" 4 | 5 | class CustomSky : public IModule { 6 | public: 7 | bool rainbow = false; 8 | float red = 0.f; 9 | float green = 0.f; 10 | float blue = 0.f; 11 | 12 | CustomSky(); 13 | virtual const char* getModuleName(); 14 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/Derp.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class Derp : public IModule { 4 | private: 5 | int counter = 0; 6 | bool headless = false; 7 | bool silent = false; 8 | bool twerk = false; 9 | bool spin = true; 10 | int Odelay = 0; 11 | int delay = 1; 12 | int tick = 0; 13 | 14 | public: 15 | Derp(); 16 | ~Derp(); 17 | 18 | // Inherited via IModule 19 | virtual void onEnable() override; 20 | virtual void onDisable() override; 21 | virtual void onTick(C_GameMode* gm) override; 22 | virtual const char* getModuleName() override; 23 | virtual void onSendPacket(C_Packet* packet) override; 24 | virtual void onPostRender(C_MinecraftUIRenderContext* renderCtx) override; 25 | }; 26 | -------------------------------------------------------------------------------- /Packet/Module/Modules/Disabler.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | 4 | class Disabler : public IModule { 5 | public: 6 | bool shouldDisable = false; 7 | int counter = 1; 8 | int c2 = 1; 9 | 10 | Disabler(); 11 | ~Disabler(); 12 | 13 | std::string name = "Disabler"; 14 | SettingEnum mode = this; 15 | 16 | // Inherited via IModule 17 | virtual void onEnable() override; 18 | virtual const char* getModuleName() override; 19 | virtual void onTick(C_GameMode* gm) override; 20 | virtual const char* getRawModuleName() override; 21 | virtual void onSendPacket(C_Packet* packet) override; 22 | 23 | inline std::vector* getMovePlayerPacketHolder() { return &MovePlayerPacketHolder; }; 24 | inline std::vector* getPlayerAuthInputPacketHolder() { return &PlayerAuthInputPacketHolder; }; 25 | std::vector MovePlayerPacketHolder; 26 | std::vector PlayerAuthInputPacketHolder; 27 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/ESP.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../ModuleManager.h" 4 | #include "Module.h" 5 | 6 | class ESP : public IModule { 7 | public: 8 | bool isMobEsp = false; 9 | bool doRainbow = true; 10 | bool is2d = false; 11 | bool tracerMode = false; 12 | ESP(); 13 | ~ESP(); 14 | 15 | SettingEnum mode = this; 16 | 17 | // Inherited via IModule 18 | void onLevelRender() override; 19 | virtual const char* getModuleName() override; 20 | virtual void onPreRender(C_MinecraftUIRenderContext* renderCtx) override; 21 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/EditionFaker.cpp: -------------------------------------------------------------------------------- 1 | #include "EditionFaker.h" 2 | 3 | EditionFaker::EditionFaker() : IModule(0, Category::EXPLOIT, "Fakes your device to IOS") { 4 | } 5 | 6 | EditionFaker::~EditionFaker() { 7 | } 8 | 9 | int EditionFaker::getFakedEditon() { 10 | static const char* gameEditons[] = {"iOS"}; 11 | 12 | return 2; // Ios 13 | } 14 | 15 | const char* EditionFaker::getModuleName() { 16 | return ("EditionFaker"); 17 | } 18 | -------------------------------------------------------------------------------- /Packet/Module/Modules/EditionFaker.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class EditionFaker : public IModule { 4 | public: 5 | EditionFaker(); 6 | ~EditionFaker(); 7 | 8 | int getFakedEditon(); 9 | 10 | // Inherited via IModule 11 | virtual const char* getModuleName() override; 12 | }; 13 | -------------------------------------------------------------------------------- /Packet/Module/Modules/Emote.cpp: -------------------------------------------------------------------------------- 1 | #include "Emote.h" 2 | 3 | Emote::Emote() : IModule(0, Category::MISC, "Multiply All Actions, Server Sided") { 4 | registerBoolSetting("4x", &fourx, fourx); 5 | } 6 | 7 | Emote::~Emote() { 8 | } 9 | 10 | const char* Emote::getModuleName() { 11 | return ("PacketMultiplier"); 12 | } -------------------------------------------------------------------------------- /Packet/Module/Modules/Emote.h: -------------------------------------------------------------------------------- 1 | 2 | #include "Module.h" 3 | class Emote : public IModule { 4 | 5 | public: 6 | Emote(); 7 | ~Emote(); 8 | bool fourx = false; 9 | 10 | // Inherited via IModule 11 | virtual const char* getModuleName() override; 12 | }; 13 | -------------------------------------------------------------------------------- /Packet/Module/Modules/EntityControl.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../ModuleManager.h" 4 | #include "Module.h" 5 | 6 | class EntityControl : public IModule { 7 | public: 8 | bool control = false; 9 | float speed = 0.f; 10 | float range = 8; 11 | 12 | EntityControl(); 13 | ~EntityControl(); 14 | 15 | virtual void onEnable() override; 16 | virtual void onDisable() override; 17 | virtual const char* getModuleName(); 18 | virtual void onTick(C_GameMode* gm) override; 19 | virtual void onMove(C_MoveInputHandler* input) override; 20 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/ExtendedBlockReach.cpp: -------------------------------------------------------------------------------- 1 | #include "ExtendedBlockReach.h" 2 | 3 | ExtendedBlockReach::ExtendedBlockReach() : IModule(0, Category::MISC, "Exteneded reach for placing/breaking blocks") { 4 | this->registerFloatSetting(std::string("reach"), &this->blockReach, this->blockReach, 50, 500); 5 | } 6 | 7 | ExtendedBlockReach::~ExtendedBlockReach() { 8 | } 9 | 10 | const char* ExtendedBlockReach::getModuleName() { 11 | return ("ExtendedBlockReach"); 12 | } 13 | -------------------------------------------------------------------------------- /Packet/Module/Modules/ExtendedBlockReach.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | 4 | class ExtendedBlockReach : public IModule { 5 | private: 6 | float blockReach = 7.f; 7 | 8 | public: 9 | ExtendedBlockReach(); 10 | ~ExtendedBlockReach(); 11 | 12 | inline float getBlockReach() { return blockReach; }; 13 | inline void setBlockReach(float reach) { blockReach = reach; }; 14 | // Inherited via IModule 15 | virtual const char* getModuleName() override; 16 | }; 17 | -------------------------------------------------------------------------------- /Packet/Module/Modules/FallSave.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | 4 | class FallSave : public IModule { 5 | private: 6 | float fDist = 3; 7 | int timerVal = 15; 8 | bool useTimer = true; 9 | bool useJump = false; 10 | bool timerWasEnabled = false; 11 | 12 | public: 13 | FallSave(); 14 | ~FallSave(); 15 | 16 | const char* getModuleName() override; 17 | virtual void onDisable() override; 18 | virtual void onEnable() override; 19 | virtual void onTick(C_GameMode* gm) override; 20 | }; 21 | -------------------------------------------------------------------------------- /Packet/Module/Modules/FastPlace.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../ModuleManager.h" 3 | #include "Module.h" 4 | 5 | class FastPlace : public IModule { 6 | private: 7 | int Odelay = 0; 8 | int delay = 0; 9 | 10 | public: 11 | FastPlace(); 12 | ~FastPlace(); 13 | 14 | // Inherited via IModule 15 | virtual const char* getModuleName() override; 16 | virtual void onTick(C_GameMode* gm) override; 17 | }; 18 | -------------------------------------------------------------------------------- /Packet/Module/Modules/FastStop.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../ModuleManager.h" 3 | #include "Module.h" 4 | 5 | class FastStop : public IModule { 6 | private: 7 | bool icey = false; 8 | int counter = 1; 9 | 10 | public: 11 | FastStop(); 12 | ~FastStop(); 13 | 14 | // Inherited via IModule 15 | virtual const char* getModuleName() override; 16 | virtual void onMove(C_MoveInputHandler* input) override; 17 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/FreeTP.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class FreeTP : public IModule { 4 | private: 5 | bool speedWasEnabled = false; 6 | float speed = 1.f; 7 | 8 | public: 9 | FreeTP(); 10 | ~FreeTP(); 11 | 12 | // Inherited via IModule 13 | virtual void onEnable() override; 14 | virtual void onMove(C_MoveInputHandler* input) override; 15 | virtual const char* getModuleName() override; 16 | virtual void onTick(C_GameMode* gm) override; 17 | virtual void onDisable() override; 18 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/Freecam.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class Freecam : public IModule { 4 | private: 5 | bool enabled = true; 6 | float speed = 1.f; 7 | vec3_t oldPos; 8 | 9 | public: 10 | Freecam(); 11 | ~Freecam(); 12 | 13 | // Inherited via IModule 14 | virtual void onMove(C_MoveInputHandler* input) override; 15 | virtual const char* getModuleName() override; 16 | virtual void onTick(C_GameMode* gm) override; 17 | virtual void onEnable() override; 18 | virtual void onDisable() override; 19 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/Freelook.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | 4 | class Freelook : public IModule { 5 | private: 6 | vec2_t initialViewAngles = {}; 7 | public: 8 | int resetViewTick = -1; 9 | vec2_t lastCameraAngle = {0, 0}; 10 | bool redirectMouse = false; 11 | bool isThirdPerson = false; 12 | bool cameraFacesFront = false; 13 | 14 | Freelook(); 15 | ~Freelook(); 16 | 17 | virtual const char* getModuleName() override; 18 | virtual bool isFlashMode() override; 19 | void onTick(C_GameMode* mode) override; 20 | void onEnable() override; 21 | void onDisable() override; 22 | void onPostRender(C_MinecraftUIRenderContext* ctx) override; 23 | bool callWhenDisabled() override { 24 | return true; 25 | } 26 | }; 27 | -------------------------------------------------------------------------------- /Packet/Module/Modules/FullBright.cpp: -------------------------------------------------------------------------------- 1 | #include "FullBright.h" 2 | 3 | FullBright::FullBright() : IModule(0, Category::VISUAL, "Puts yDeiDeeDeiDerrtDord to maximum ye") { 4 | } 5 | 6 | FullBright::~FullBright() { 7 | } 8 | 9 | const char* FullBright::getModuleName() { 10 | return "Fullbright"; 11 | } 12 | -------------------------------------------------------------------------------- /Packet/Module/Modules/FullBright.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class FullBright : public IModule { 4 | public: 5 | 6 | FullBright(); 7 | ~FullBright(); 8 | 9 | // Inherited via IModule 10 | virtual const char* getModuleName() override; 11 | }; 12 | -------------------------------------------------------------------------------- /Packet/Module/Modules/Hitbox.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../../../Utils/Target.h" 3 | #include "../ModuleManager.h" 4 | #include "Module.h" 5 | 6 | class Hitbox : public IModule { 7 | public: 8 | float height = 3; 9 | float width = 4; 10 | float range = 8; 11 | 12 | Hitbox(); 13 | ~Hitbox(); 14 | 15 | // Inherited via IModule 16 | virtual const char* getModuleName() override; 17 | virtual void onTick(C_GameMode* gm) override; 18 | }; 19 | -------------------------------------------------------------------------------- /Packet/Module/Modules/HiveFly.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class HiveFly : public IModule { 4 | private: 5 | public: 6 | HiveFly(); 7 | ~HiveFly(); 8 | 9 | // Inherited via IModule 10 | virtual const char* getModuleName() override; 11 | virtual void onMove(C_MoveInputHandler* input) override; 12 | virtual void onEnable() override; 13 | virtual void onDisable() override; 14 | virtual void onLevelRender(); 15 | virtual void onSendPacket(C_Packet* packet); 16 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/HudEditorMod.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Module.h" 4 | 5 | class HudEditorMod : public IModule { 6 | public: 7 | bool initialized = false; 8 | int timesRendered2 = 0; 9 | 10 | HudEditorMod(); 11 | ~HudEditorMod(); 12 | 13 | virtual const char* getModuleName(); 14 | virtual void onTick(C_GameMode* gm) override; 15 | virtual void onDisable() override; 16 | virtual void onEnable() override; 17 | virtual bool allowAutoStart() override; 18 | virtual void onPostRender(C_MinecraftUIRenderContext* renderCtx) override; 19 | //virtual void onLoadConfig(void* conf) override; 20 | //virtual void onSaveConfig(void* conf) override; 21 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/InPvPFucker.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../../Utils/Target.h" 4 | #include "../ModuleManager.h" 5 | #include "Module.h" 6 | 7 | class InPvPFucker : public IModule { 8 | public: 9 | bool towerWars = false; 10 | bool skyWars = false; 11 | bool newGame = false; 12 | int Odelay = 0; 13 | int count = 0; 14 | int delay = 0; 15 | int tps = 250; 16 | 17 | // Teams 18 | bool blueTeam = false; 19 | bool redTeam = false; 20 | 21 | InPvPFucker(); 22 | 23 | std::string name = ("InPvPFucker"); 24 | SettingEnum mode = this; 25 | 26 | // Inherited via IModule 27 | virtual const char* getModuleName() override; 28 | virtual void onTick(C_GameMode* gm) override; 29 | virtual void onEnable() override; 30 | virtual void onDisable() override; 31 | virtual const char* getRawModuleName() override; 32 | virtual void onSendPacket(C_Packet* packet) override; 33 | virtual void onPostRender(C_MinecraftUIRenderContext* renderCtx) override; 34 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/InstaBreak.cpp: -------------------------------------------------------------------------------- 1 | #include "InstaBreak.h" 2 | 3 | InstaBreak::InstaBreak() : IModule(0, Category::EXPLOIT, "Break any block instantly") { 4 | registerBoolSetting("Hold", &breakBlocks, breakBlocks); 5 | //registerBoolSetting("Hive", &hive, hive); 6 | } 7 | 8 | InstaBreak::~InstaBreak() { 9 | } 10 | 11 | const char* InstaBreak::getModuleName() { 12 | return ("InstaBreak"); 13 | } 14 | 15 | void InstaBreak::onEnable() { 16 | i = 0; 17 | } 18 | 19 | void InstaBreak::onTick(C_GameMode* gm) { 20 | if (g_Data.canUseMoveKeys()) { 21 | if (hive) { 22 | 23 | } else if (breakBlocks) { 24 | if (!g_Data.isLeftClickDown()) 25 | return; 26 | PointingStruct* pointing = g_Data.getClientInstance()->getPointerStruct(); 27 | bool isDestroyed = false; 28 | gm->startDestroyBlock(pointing->block, 1, isDestroyed); 29 | gm->destroyBlock(&pointing->block, pointing->blockSide); 30 | } 31 | } 32 | } -------------------------------------------------------------------------------- /Packet/Module/Modules/InstaBreak.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | 4 | class InstaBreak : public IModule { 5 | public: 6 | bool breakBlocks = false; 7 | bool hive = false; 8 | int delay = 0; 9 | int Odelay = 0; 10 | int i = 0; 11 | 12 | InstaBreak(); 13 | ~InstaBreak(); 14 | 15 | // Inherited via IModule 16 | virtual void onEnable() override; 17 | virtual void onTick(C_GameMode* gm) override; 18 | virtual const char* getModuleName() override; 19 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/InvManager.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class InvManager : public IModule { 4 | private: 5 | bool sorted = false; 6 | 7 | std::vector findStackableItems(); 8 | std::vector findUselessItems(); 9 | bool isLastItem(C_Item* item); 10 | int Odelay = 0; 11 | int delay = 0; 12 | 13 | bool openInv = false; 14 | bool autoSort = true; 15 | bool clean = true; 16 | bool keep = true; 17 | 18 | // Slots 19 | int swordSlot = 0; 20 | int pickSlot = 1; 21 | int axeSlot = 2; 22 | int blockSlot = 9; 23 | 24 | public: 25 | bool stackIsUseful(C_ItemStack* itemStack); 26 | bool autoDisable = false; 27 | 28 | InvManager(); 29 | ~InvManager(); 30 | 31 | std::string name = "InvManager"; 32 | 33 | // Inherited via IModule 34 | virtual const char* getModuleName() override; 35 | virtual void onTick(C_GameMode* gm) override; 36 | virtual const char* getRawModuleName() override; 37 | }; 38 | -------------------------------------------------------------------------------- /Packet/Module/Modules/InventoryCleaner.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class InventoryCleaner : public IModule { 4 | private: 5 | bool sorted = false; 6 | 7 | std::vector findStackableItems(); 8 | std::vector findUselessItems(); 9 | bool isLastItem(C_Item* item); 10 | 11 | bool clean = true; 12 | bool keepTools = true; 13 | bool keepArmor = true; 14 | bool keepBlocks = true; 15 | bool keepFood = true; 16 | 17 | bool openInv = true; 18 | int test = 0; 19 | bool autoSort = true; 20 | 21 | // Slots 22 | int swordSlot = 0; 23 | int pickSlot = 1; 24 | int axeSlot = 2; 25 | int blockSlot = 9; 26 | 27 | public: 28 | bool stackIsUseful(C_ItemStack* itemStack); 29 | InventoryCleaner(); 30 | ~InventoryCleaner(); 31 | 32 | // Inherited via IModule 33 | virtual const char* getModuleName() override; 34 | virtual void onTick(C_GameMode* gm) override; 35 | }; 36 | -------------------------------------------------------------------------------- /Packet/Module/Modules/InventoryMove.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class InventoryMove : public IModule { 4 | private: 5 | bool keyPressed = false; 6 | 7 | public: 8 | InventoryMove(); 9 | ~InventoryMove(); 10 | 11 | // Inherited via IModule 12 | virtual const char* getModuleName() override; 13 | virtual void onTick(C_GameMode* gm) override; 14 | }; 15 | -------------------------------------------------------------------------------- /Packet/Module/Modules/ItemTP.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Module.h" 4 | 5 | class ItemTP : public IModule { 6 | public: 7 | int range = 20; 8 | int delay = 0; 9 | vec3_t prevPos; 10 | int Odelay = 0; 11 | 12 | ItemTP(); 13 | virtual void onEnable() override; 14 | virtual void onDisable() override; 15 | virtual const char* getModuleName(); 16 | virtual void onTick(C_GameMode* gm) override; 17 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/JavascriptModule.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | #include "../../Scripting/ScriptInstance.h" 4 | 5 | class JsScriptModule; 6 | 7 | class JavascriptModule : public IModule { 8 | private: 9 | std::weak_ptr backingScriptModule; 10 | 11 | public: 12 | JavascriptModule(); 13 | ~JavascriptModule(); 14 | 15 | void setBackingScript(std::shared_ptr); 16 | std::weak_ptr getBackingScriptModule(); 17 | 18 | // Inherited via IModule 19 | virtual void onSaveConfig(void*) override{}; // delete 20 | virtual const char* getModuleName() override; 21 | virtual void onTick(C_GameMode* gm) override; 22 | void onEnable() override; 23 | void onDisable() override; 24 | void onLevelRender() override; 25 | void onPreRender(C_MinecraftUIRenderContext* renderCtx) override; 26 | }; 27 | -------------------------------------------------------------------------------- /Packet/Module/Modules/Jesus.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class Jesus : public IModule { 4 | private: 5 | bool tryJesus(vec3_t blockBelow); 6 | float height = 0.5; 7 | bool smthwateridk = false; 8 | 9 | public: 10 | Jesus(); 11 | ~Jesus(); 12 | 13 | SettingEnum mode = this; 14 | std::string name = "Jesus"; 15 | 16 | // Inherited via IModule 17 | virtual const char* getModuleName() override; 18 | virtual void onTick(C_GameMode* gm) override; 19 | virtual const char* getRawModuleName() override; 20 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/Jetpack.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | 4 | class Jetpack : public IModule { 5 | private: 6 | int delay = 0; 7 | bool isBypass = false; 8 | float speedMod = 1; 9 | 10 | public: 11 | C_MovePlayerPacket* jetpack = nullptr; 12 | Jetpack(); 13 | ~Jetpack(); 14 | 15 | virtual void onTick(C_GameMode* gm) override; 16 | virtual bool isFlashMode() override; 17 | 18 | // Inherited via IModule 19 | virtual const char* getModuleName() override; 20 | }; 21 | -------------------------------------------------------------------------------- /Packet/Module/Modules/KBFly.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | #include "../ModuleManager.h" 4 | 5 | class KBFly : public IModule { 6 | private: 7 | float speedMod = 1; 8 | bool stop = true; 9 | float standVel = 0; 10 | float moveVel = 0; 11 | bool resetValues = false; 12 | bool vanf = false; 13 | bool keyPressed = false; 14 | float vanFYVel = 1; 15 | bool nostop = false; 16 | bool helper = false; 17 | bool turnOnGold = false; 18 | bool goldWasOn = false; 19 | 20 | public: 21 | KBFly(); 22 | ~KBFly(); 23 | 24 | virtual void onTick(C_GameMode* gm) override; 25 | virtual void onEnable() override; 26 | virtual void onDisable() override; 27 | // Inherited via IModule 28 | virtual const char* getModuleName() override; 29 | }; 30 | -------------------------------------------------------------------------------- /Packet/Module/Modules/LongJump.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Module.h" 4 | 5 | class LongJump : public IModule { 6 | private: 7 | float glideMod = -0.16f; 8 | int counter = 1; 9 | int counter2 = 0; 10 | bool damage = false; 11 | bool slowDown = true; 12 | bool old = false; 13 | float height = 1.f; 14 | float speed = 2.f; 15 | 16 | SettingEnum mode = this; 17 | 18 | public: 19 | LongJump(); 20 | //virtual void onTick(C_GameMode* gm) override; 21 | virtual const char* getModuleName(); 22 | virtual void onTick(C_GameMode* gm) override; 23 | virtual void onEnable() override; 24 | virtual void onDisable() override; 25 | virtual void onMove(C_MoveInputHandler* input) override; 26 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/MidClick.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class MidClick : public IModule { 4 | private: 5 | bool hasClicked = false; 6 | 7 | public: 8 | MidClick(); 9 | ~MidClick(); 10 | // Inherited via IModule 11 | virtual const char* getModuleName() override; 12 | virtual void onTick(C_GameMode* gm) override; 13 | }; 14 | -------------------------------------------------------------------------------- /Packet/Module/Modules/NameTags.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Module.h" 4 | 5 | class NameTags : public IModule { 6 | public: 7 | std::set nameTags; 8 | bool displayArmor = true; 9 | bool underline = true; 10 | float opacity = 0.5f; 11 | NameTags(); 12 | ~NameTags(); 13 | 14 | bool* ingameNametagSetting = nullptr; 15 | bool lastSetting = true; 16 | bool gotPrevSetting = false; 17 | 18 | // Inherited via IModule 19 | virtual const char* getModuleName() override; 20 | virtual void onPreRender(C_MinecraftUIRenderContext* renderCtx) override; 21 | virtual void onDisable() override; 22 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/Nbt.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | 4 | class Nbt : public IModule { 5 | private: 6 | std::string lastCopy; 7 | 8 | public: 9 | Nbt(); 10 | ~Nbt(); 11 | 12 | virtual const char* getModuleName() override; 13 | virtual void onTick(C_GameMode* gm) override; 14 | }; 15 | -------------------------------------------------------------------------------- /Packet/Module/Modules/NoFall.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Module.h" 4 | 5 | class NoFall : public IModule { 6 | public: 7 | int dist = 3; 8 | 9 | std::string name = "Killaura"; 10 | C_MoveInputHandler* inputHandler = nullptr; 11 | SettingEnum mode = this; 12 | 13 | NoFall(); 14 | virtual const char* getModuleName(); 15 | virtual void onTick(C_GameMode* gm) override; 16 | virtual const char* getRawModuleName() override; 17 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/NoFriends.cpp: -------------------------------------------------------------------------------- 1 | #include "NoFriends.h" 2 | 3 | NoFriends::NoFriends() : IModule(0, Category::PLAYER, "Ignores friend list check") { 4 | } 5 | 6 | NoFriends::~NoFriends() { 7 | } 8 | 9 | const char* NoFriends::getModuleName() { 10 | return ("NoFriends"); 11 | } 12 | -------------------------------------------------------------------------------- /Packet/Module/Modules/NoFriends.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../DrawUtils.h" 4 | #include "Module.h" 5 | 6 | class NoFriends : public IModule { 7 | public: 8 | NoFriends(); 9 | ~NoFriends(); 10 | 11 | // Inherited via IModule 12 | virtual const char* getModuleName() override; 13 | }; 14 | -------------------------------------------------------------------------------- /Packet/Module/Modules/NoJumpDelay.cpp: -------------------------------------------------------------------------------- 1 | #include "NoJumpDelay.h" 2 | 3 | NoJumpDelay::NoJumpDelay() : IModule(0, Category::PLAYER, "No delay between jumps") { 4 | } 5 | NoJumpDelay::~NoJumpDelay() { 6 | } 7 | 8 | void NoJumpDelay::onTick(C_GameMode* gm) { 9 | C_GameSettingsInput* input = g_Data.getClientInstance()->getGameSettingsInput(); 10 | if (g_Data.getLocalPlayer() == nullptr) 11 | return; 12 | if (!g_Data.canUseMoveKeys()) 13 | return; 14 | 15 | if (gm->player->onGround && GameData::isKeyDown(*input->spaceBarKey)) { 16 | gm->player->jumpFromGround(); 17 | } 18 | } 19 | 20 | const char* NoJumpDelay::getModuleName() { 21 | return "NoJumpDelay"; 22 | } -------------------------------------------------------------------------------- /Packet/Module/Modules/NoJumpDelay.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | 4 | class NoJumpDelay : public IModule { 5 | public: 6 | NoJumpDelay(); 7 | ~NoJumpDelay(); 8 | 9 | virtual void onTick(C_GameMode* gm) override; 10 | const char* getModuleName() override; 11 | }; 12 | -------------------------------------------------------------------------------- /Packet/Module/Modules/NoPacket.cpp: -------------------------------------------------------------------------------- 1 | #include "NoPacket.h" 2 | 3 | NoPacket::NoPacket() : IModule(0, Category::MISC, "Prevents you from sending InventoryTransaction packets") { 4 | } 5 | 6 | NoPacket::~NoPacket() { 7 | } 8 | 9 | const char* NoPacket::getModuleName() { 10 | return ("NoPacket"); 11 | } 12 | bool NoPacket::allowAutoStart() { 13 | return false; 14 | } 15 | void NoPacket::onEnable() { 16 | if(!g_Data.isInGame()) 17 | this->setEnabled(false); 18 | } 19 | -------------------------------------------------------------------------------- /Packet/Module/Modules/NoPacket.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class NoPacket : public IModule { 4 | public: 5 | NoPacket(); 6 | ~NoPacket(); 7 | 8 | // Inherited via IModule 9 | virtual const char* getModuleName() override; 10 | bool allowAutoStart() override; 11 | void onEnable() override; 12 | }; 13 | -------------------------------------------------------------------------------- /Packet/Module/Modules/NoSlow.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class NoSlow : public IModule { 4 | private: 5 | uint8_t* opcode = 0; 6 | uint8_t* opcode1 = 0; 7 | bool noweb = false; 8 | 9 | public: 10 | NoSlow(); 11 | ~NoSlow(); 12 | 13 | // Inherited via IModule 14 | virtual const char* getModuleName() override; 15 | virtual void onEnable() override; 16 | virtual void onTick(C_GameMode* gm) override; 17 | virtual void onDisable() override; 18 | }; 19 | -------------------------------------------------------------------------------- /Packet/Module/Modules/NoSwing.cpp: -------------------------------------------------------------------------------- 1 | #include "NoSwing.h" 2 | 3 | NoSwing::NoSwing() : IModule(0, Category::PLAYER, "Disable arm swing animation for killaura, triggerbot, fucker etc.") { 4 | } 5 | 6 | NoSwing::~NoSwing() { 7 | } 8 | 9 | const char* NoSwing::getModuleName() { 10 | return ("NoSwing"); 11 | } -------------------------------------------------------------------------------- /Packet/Module/Modules/NoSwing.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class NoSwing : public IModule { 4 | public: 5 | NoSwing(); 6 | ~NoSwing(); 7 | 8 | // Inherited via IModule 9 | virtual const char* getModuleName() override; 10 | }; 11 | -------------------------------------------------------------------------------- /Packet/Module/Modules/Notifications.cpp: -------------------------------------------------------------------------------- 1 | #include "Notifications.h" 2 | 3 | Notifications::Notifications() : IModule(0, Category::VISUAL, "Notifications") { 4 | //registerBoolSetting("Disable", &disable, &disable); 5 | //registerBoolSetting("Enable", &enable, &enable); 6 | registerFloatSetting("Opacity", &opacity, opacity, 0.f, 1.f); 7 | } 8 | 9 | Notifications::~Notifications() { 10 | } 11 | 12 | void Notifications::onEnable() { 13 | auto box = g_Data.addInfoBox("Module:", "Example Notification"); 14 | box->closeTimer = 13; // 13 15 | setEnabled(false); 16 | } 17 | 18 | const char* Notifications::getModuleName() { 19 | return ("Notifications"); 20 | } -------------------------------------------------------------------------------- /Packet/Module/Modules/Notifications.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../ModuleManager.h" 3 | #include "Module.h" 4 | 5 | class Notifications : public IModule { 6 | private: 7 | public: 8 | bool firstLetter = false; 9 | bool modInfo = false; 10 | bool enable = true; 11 | bool disable = true; 12 | float opacity = 0.6; 13 | 14 | Notifications(); 15 | ~Notifications(); 16 | 17 | SettingEnum mode = this; 18 | 19 | // Inherited via IModule 20 | virtual void onEnable() override; 21 | virtual const char* getModuleName() override; 22 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/Nuker.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | 4 | class Nuker : public IModule { 5 | private: 6 | int delay = 0; 7 | int nukerRadius = 4; 8 | bool tree = false; 9 | int up = 4; 10 | int down = 4; 11 | bool veinMiner = false; 12 | bool ore = false; 13 | bool autodestroy = false; 14 | 15 | public: 16 | Nuker(); 17 | ~Nuker(); 18 | 19 | inline bool isAutoMode() { return autodestroy; }; 20 | int getNukerRadius() { return nukerRadius; }; 21 | inline bool treeMode() { return tree; }; 22 | int getDownRadius() { return down; }; 23 | int getUpRadius() { return up; }; 24 | 25 | inline bool isVeinMiner() { return veinMiner; }; 26 | // Inherited via IModule 27 | virtual const char* getModuleName() override; 28 | virtual void onTick(C_GameMode* gm) override; 29 | }; 30 | -------------------------------------------------------------------------------- /Packet/Module/Modules/Packet.cpp: -------------------------------------------------------------------------------- 1 | #include "Packet.h" 2 | 3 | Packet::Packet() : IModule(0, Category::EXPLOIT, "Multiply / Cancel all actions server sided") { 4 | registerBoolSetting("NoPacket", &noPacket, noPacket); 5 | registerBoolSetting("Multiply", &multiply, multiply); 6 | //registerBoolSetting("Multiply4x", &fourx, fourx); 7 | } 8 | 9 | Packet::~Packet() { 10 | } 11 | 12 | const char* Packet::getRawModuleName() { 13 | return "Packet"; 14 | } 15 | 16 | const char* Packet::getModuleName() { 17 | if (multiply) { 18 | name = std::string("Packet ") + std::string(GRAY) + std::string("Multiply"); 19 | return name.c_str(); 20 | } else if (!multiply) { 21 | return "Packet"; 22 | } 23 | } 24 | 25 | bool Packet::allowAutoStart() { 26 | return false; 27 | } 28 | 29 | void Packet::onEnable() { 30 | if (!g_Data.isInGame()) 31 | setEnabled(false); 32 | } -------------------------------------------------------------------------------- /Packet/Module/Modules/Packet.h: -------------------------------------------------------------------------------- 1 | 2 | #include "Module.h" 3 | class Packet : public IModule { 4 | 5 | public: 6 | bool fourx = false; 7 | bool multiply = false; 8 | bool noPacket = false; 9 | 10 | Packet(); 11 | ~Packet(); 12 | 13 | std::string name = "Packet"; 14 | 15 | // Inherited via IModule 16 | void onEnable() override; 17 | bool allowAutoStart() override; 18 | virtual const char* getModuleName() override; 19 | virtual const char* getRawModuleName() override; 20 | }; 21 | -------------------------------------------------------------------------------- /Packet/Module/Modules/PacketLogger.cpp: -------------------------------------------------------------------------------- 1 | #include "PacketLogger.h" 2 | 3 | PacketLogger::PacketLogger() : IModule(0, Category::MISC, "Logging Packets!") { 4 | } 5 | 6 | PacketLogger::~PacketLogger() { 7 | } 8 | 9 | const char* PacketLogger::getModuleName() { 10 | return ("Logger"); 11 | } 12 | 13 | void PacketLogger::onSendPacket(C_Packet* packet) { 14 | if (packet->isInstanceOf()) { 15 | auto pk = reinterpret_cast(packet); 16 | g_Data.getClientInstance()->getGuiData()->displayClientMessageF("[PACKETLOG] %s action=%i", packet->getName()->getText(), pk->action); 17 | return; 18 | } 19 | g_Data.getClientInstance()->getGuiData()->displayClientMessageF("[PACKETLOG] %s", packet->getName()->getText()); 20 | } 21 | -------------------------------------------------------------------------------- /Packet/Module/Modules/PacketLogger.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class PacketLogger : public IModule { 4 | public: 5 | PacketLogger(); 6 | ~PacketLogger(); 7 | 8 | // Inherited via IModule 9 | virtual const char* getModuleName() override; 10 | virtual void onSendPacket(C_Packet* packet) override; 11 | }; 12 | -------------------------------------------------------------------------------- /Packet/Module/Modules/Phase.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | 4 | class Phase : public IModule { 5 | private: 6 | bool vertMode = false; 7 | 8 | public: 9 | Phase(); 10 | ~Phase(); 11 | 12 | std::string name = "Phase"; 13 | SettingEnum mode = this; 14 | 15 | virtual void onDisable() override; 16 | virtual const char* getModuleName() override; 17 | virtual void onTick(C_GameMode* gm) override; 18 | virtual const char* getRawModuleName() override; 19 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/PlayerList.cpp: -------------------------------------------------------------------------------- 1 | #include "PlayerList.h" 2 | 3 | PlayerList::PlayerList() : IModule(VK_TAB, Category::CONFIG, "PlayerList") { 4 | } 5 | 6 | const char* PlayerList::getModuleName() { 7 | return "PlayerList"; 8 | } 9 | 10 | PlayerList::~PlayerList() { 11 | } 12 | 13 | static std::vector playerList; 14 | 15 | void findPlayers(C_Entity* currentEntity, bool isRegularEntity) { 16 | if (currentEntity == nullptr) 17 | return; 18 | 19 | if (!Target::isValidTarget(currentEntity)) 20 | return; 21 | 22 | if (currentEntity->getEntityTypeId() != 319) 23 | return; 24 | 25 | playerList.push_back(currentEntity); 26 | } 27 | 28 | bool PlayerList::isFlashMode() { 29 | return true; 30 | } 31 | 32 | void PlayerList::onTick(C_GameMode* gm) { 33 | auto player = g_Data.getLocalPlayer(); 34 | playerList.clear(); 35 | g_Data.forEachEntity(findPlayers); 36 | } 37 | 38 | void PlayerList::onPostRender(C_MinecraftUIRenderContext* renderCtx) { 39 | } -------------------------------------------------------------------------------- /Packet/Module/Modules/PlayerList.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../../../Utils/Target.h" 3 | #include "../ModuleManager.h" 4 | #include "Module.h" 5 | 6 | class PlayerList : public IModule { 7 | public: 8 | float range = 255; 9 | 10 | PlayerList(); 11 | ~PlayerList(); 12 | 13 | virtual bool isFlashMode() override; 14 | virtual const char* getModuleName(); 15 | virtual void onTick(C_GameMode* gm) override; 16 | virtual void onPostRender(C_MinecraftUIRenderContext* renderCtx) override; 17 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/Radar.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | #include "../../DrawUtils.h" 4 | class Radar : public IModule { 5 | public: 6 | Radar(); 7 | ~Radar(); 8 | 9 | // Inherited via IModule 10 | virtual const char* getModuleName() override; 11 | virtual void onPreRender(C_MinecraftUIRenderContext* renderCtx) override; 12 | }; 13 | -------------------------------------------------------------------------------- /Packet/Module/Modules/RainbowSky.cpp: -------------------------------------------------------------------------------- 1 | #include "RainbowSky.h" 2 | 3 | RainbowSky::RainbowSky() : IModule(0, Category::VISUAL, "Gaybow sky!") { 4 | } 5 | 6 | RainbowSky::~RainbowSky() { 7 | } 8 | 9 | const char* RainbowSky::getModuleName() { 10 | return ("RainbowSky"); 11 | } 12 | -------------------------------------------------------------------------------- /Packet/Module/Modules/RainbowSky.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class RainbowSky : public IModule { 4 | public: 5 | RainbowSky(); 6 | ~RainbowSky(); 7 | 8 | // Inherited via IModule 9 | virtual const char* getModuleName() override; 10 | }; 11 | -------------------------------------------------------------------------------- /Packet/Module/Modules/Reach.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | 4 | class Reach : public IModule { 5 | private: 6 | float reachValue = 8; 7 | float originalReach = 0; 8 | float* reachPtr = nullptr; 9 | unsigned long oldProtect = 0; 10 | 11 | public: 12 | Reach(); 13 | ~Reach(); 14 | 15 | // Inherited via IModule 16 | virtual const char* getModuleName() override; 17 | virtual void onEnable() override; 18 | virtual void onDisable() override; 19 | virtual void onTick(C_GameMode* gm) override; 20 | }; 21 | -------------------------------------------------------------------------------- /Packet/Module/Modules/Safewalk.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Module.h" 4 | 5 | class Safewalk : public IModule { 6 | private: 7 | bool onEdge = false; 8 | 9 | public: 10 | 11 | Safewalk(); 12 | SettingEnum mode = this; 13 | 14 | virtual void onDisable() override; 15 | virtual const char* getModuleName(); 16 | virtual void onTick(C_GameMode* gm) override; 17 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/Sneak.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class Sneak : public IModule { 4 | private: 5 | public: 6 | bool doSilent = false; 7 | Sneak(); 8 | ~Sneak(); 9 | 10 | virtual const char* getModuleName() override; 11 | virtual void onTick(C_GameMode* gm) override; 12 | virtual void onDisable() override; 13 | virtual void onEnable() override; 14 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/Spammer.cpp: -------------------------------------------------------------------------------- 1 | #include "Spammer.h" 2 | 3 | #include "../../../Utils/Utils.h" 4 | 5 | Spammer::Spammer() : IModule(0, Category::MISC, "Spams a message in a specified delay") { 6 | registerBoolSetting("bypass", &this->bypass, this->bypass); 7 | registerIntSetting("delay", &this->delay, this->delay, 0, 30); 8 | registerIntSetting("Length", &this->length, this->length, 1, 40); 9 | } 10 | 11 | Spammer::~Spammer() { 12 | } 13 | 14 | const char* Spammer::getModuleName() { 15 | return ("Spammer"); 16 | } 17 | 18 | void Spammer::onTick(C_GameMode* gm) { 19 | Odelay++; 20 | if (Odelay > delay * 20) { 21 | C_TextPacket textPacket; 22 | textPacket.message.setText(bypass ? (message + " | " + Utils::randomString(length)) : message); 23 | textPacket.sourceName.setText(g_Data.getLocalPlayer()->getNameTag()->getText()); 24 | textPacket.messageType = 69; 25 | g_Data.getClientInstance()->loopbackPacketSender->sendToServer(&textPacket); 26 | Odelay = 0; 27 | } 28 | } -------------------------------------------------------------------------------- /Packet/Module/Modules/Spammer.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | 4 | class Spammer : public IModule { 5 | private: 6 | int Odelay = 0; 7 | bool bypass = true; 8 | int delay = 2; 9 | int length = 8; 10 | std::string message = "Packet Client - The best client for MCBE | discord.gg/J3vUwUWRVq"; 11 | 12 | public: 13 | Spammer(); 14 | ~Spammer(); 15 | 16 | inline std::string& getMessage() { return message; }; 17 | inline int& getDelay() { return delay; }; 18 | inline bool& getBypass() { return bypass; }; 19 | 20 | // Inherited via IModule 21 | virtual const char* getModuleName() override; 22 | virtual void onTick(C_GameMode* gm) override; 23 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/SpawnTP.cpp: -------------------------------------------------------------------------------- 1 | #include "SpawnTP.h" 2 | 3 | SpawnTP::SpawnTP() : IModule(0, Category::EXPLOIT, "TPS you to the spawnpoint") { 4 | } 5 | 6 | const char* SpawnTP::getModuleName() { 7 | return "SpawnTP"; 8 | } 9 | 10 | void SpawnTP::onEnable() { 11 | if (g_Data.getLocalPlayer() == nullptr) 12 | return; 13 | auto player = g_Data.getLocalPlayer(); 14 | player->setSleeping(true); 15 | auto notification = g_Data.addInfoBox("SpawnTP:", "Teleported!"); 16 | notification->closeTimer = 9; 17 | setEnabled(false); 18 | } 19 | 20 | void SpawnTP::onTick(C_GameMode* gm) { 21 | } 22 | 23 | void SpawnTP::onDisable() { 24 | } -------------------------------------------------------------------------------- /Packet/Module/Modules/SpawnTP.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Module.h" 4 | 5 | class SpawnTP : public IModule { 6 | public: 7 | 8 | SpawnTP(); 9 | 10 | virtual void onEnable() override; 11 | virtual void onDisable() override; 12 | virtual const char* getModuleName(); 13 | virtual void onTick(C_GameMode* gm) override; 14 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/Spider.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class Spider : public IModule { 4 | private: 5 | float speed = 0.6f; 6 | bool dontOvershoot = true; 7 | 8 | public: 9 | Spider(); 10 | ~Spider(); 11 | 12 | // Inherited via IModule 13 | virtual const char* getModuleName() override; 14 | virtual void onMove(C_MoveInputHandler* input) override; 15 | }; 16 | -------------------------------------------------------------------------------- /Packet/Module/Modules/Sprint.cpp: -------------------------------------------------------------------------------- 1 | #include "../../Module/ModuleManager.h" 2 | #include "Sprint.h" 3 | 4 | Sprint::Sprint() : IModule(0, Category::MOVEMENT, "Sprints automatically.") { 5 | } 6 | 7 | Sprint::~Sprint() { 8 | } 9 | 10 | const char* Sprint::getModuleName() { 11 | return ("Sprint"); 12 | } 13 | 14 | void Sprint::onTick(C_GameMode* gm) { 15 | if (useSprint) { 16 | if (!gm->player->isSprinting() && gm->player->velocity.magnitudexz() > 0.01f) { 17 | C_GameSettingsInput* input = g_Data.getClientInstance()->getGameSettingsInput(); 18 | if (omniSprint || GameData::isKeyDown(*input->forwardKey)) 19 | gm->player->setSprinting(true); 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /Packet/Module/Modules/Sprint.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class Sprint : public IModule { 4 | public: 5 | bool omniSprint = false; 6 | bool useSprint = true; 7 | 8 | Sprint(); 9 | ~Sprint(); 10 | 11 | virtual void onTick(C_GameMode* gm) override; 12 | virtual const char* getModuleName() override; 13 | }; 14 | -------------------------------------------------------------------------------- /Packet/Module/Modules/StackableItem.cpp: -------------------------------------------------------------------------------- 1 | #include "StackableItem.h" 2 | 3 | StackableItem::StackableItem() : IModule(0, Category::MISC, "Stack items you normally wouldn't be able to stack (e. g. swords)") { 4 | } 5 | 6 | StackableItem::~StackableItem() { 7 | } 8 | 9 | const char* StackableItem::getModuleName() { 10 | return ("StackableItem"); 11 | } 12 | 13 | void StackableItem::onTick(C_GameMode* gm) { 14 | C_PlayerInventoryProxy* supplies = g_Data.getLocalPlayer()->getSupplies(); 15 | C_Inventory* a = supplies->inventory; 16 | for (int i = 0; i < 36; i++) { 17 | C_ItemStack* stack = a->getItemStack(i); 18 | if (stack->item != NULL) { 19 | C_Item* item = *stack->item; 20 | item->setStackedByData(true); 21 | item->setMaxStackSize(64); 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /Packet/Module/Modules/StackableItem.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | 4 | class StackableItem : public IModule { 5 | public: 6 | StackableItem(); 7 | ~StackableItem(); 8 | 9 | virtual const char* getModuleName() override; 10 | virtual void onTick(C_GameMode* gm) override; 11 | }; 12 | -------------------------------------------------------------------------------- /Packet/Module/Modules/Step.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "..\ModuleManager.h" 3 | #include "Module.h" 4 | class Step : public IModule { 5 | public: 6 | bool reverse = false; 7 | float height = 1.5f; 8 | int timer = 20; 9 | 10 | Step(); 11 | ~Step(); 12 | 13 | std::string name = "Step"; 14 | SettingEnum mode = this; 15 | 16 | // Inherited via IModule 17 | virtual void onMove(C_MoveInputHandler* input) override; 18 | virtual const char* getRawModuleName() override; 19 | virtual const char* getModuleName() override; 20 | virtual void onTick(C_GameMode* gm) override; 21 | virtual void onDisable() override; 22 | }; 23 | -------------------------------------------------------------------------------- /Packet/Module/Modules/Switcher.h: -------------------------------------------------------------------------------- 1 | #include "Module.h" 2 | 3 | class Switcher : public IModule { 4 | private: 5 | int ternary = false; 6 | int ternary1 = false; 7 | bool autos = false; 8 | bool ss = false; 9 | bool swap = false; 10 | bool ownage = false; 11 | bool ternaryO = false; 12 | bool toggler = false; 13 | 14 | public: 15 | Switcher(); 16 | ~Switcher(); 17 | 18 | // Inherited via IModule 19 | virtual const char* getModuleName() override; 20 | virtual void onEnable() override; 21 | virtual void onAttack(C_Entity* attackedEnt) override; 22 | virtual void onTick(C_GameMode* gm) override; 23 | }; 24 | -------------------------------------------------------------------------------- /Packet/Module/Modules/TargetHUD.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../../../Utils/Target.h" 3 | #include "../ModuleManager.h" 4 | #include "Module.h" 5 | 6 | class TargetHUD : public IModule { 7 | public: 8 | bool hurttime = false; 9 | int targethud = 0; 10 | 11 | TargetHUD(); 12 | ~TargetHUD(); 13 | 14 | SettingEnum mode = this; 15 | 16 | // Inherited via IModule 17 | virtual void onEnable() override; 18 | virtual void onDisable() override; 19 | virtual const char* getModuleName() override; 20 | virtual void onTick(C_GameMode* gm) override; 21 | virtual void onPreRender(C_MinecraftUIRenderContext* renderCtx) override; 22 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/Teams.cpp: -------------------------------------------------------------------------------- 1 | #include "Teams.h" 2 | 3 | Teams::Teams() : IModule(0, Category::COMBAT, "Don't attack team members!") { 4 | registerBoolSetting("Server", &this->alliedCheck, this->alliedCheck); 5 | registerBoolSetting("Color", &this->colorCheck, this->colorCheck); 6 | } 7 | 8 | Teams::~Teams() { 9 | } 10 | 11 | const char* Teams::getModuleName() { 12 | return ("Teams"); 13 | } 14 | -------------------------------------------------------------------------------- /Packet/Module/Modules/Teams.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class Teams : public IModule { 4 | private: 5 | bool alliedCheck = false; 6 | bool colorCheck = true; 7 | 8 | public: 9 | Teams(); 10 | ~Teams(); 11 | 12 | bool isAlliedCheckEnabled() { return this->isEnabled() && alliedCheck; }; 13 | bool isColorCheckEnabled() { return this->isEnabled() && colorCheck; }; 14 | 15 | // Inherited via IModule 16 | virtual const char* getModuleName() override; 17 | }; 18 | -------------------------------------------------------------------------------- /Packet/Module/Modules/TimeChanger.cpp: -------------------------------------------------------------------------------- 1 | #include "TimeChanger.h" 2 | 3 | TimeChanger::TimeChanger() : IModule(0, Category::VISUAL, "Changes the client-sided time.") { 4 | registerFloatSetting("Value", &modifier, modifier, 0.1f, 1.f); 5 | } 6 | 7 | TimeChanger::~TimeChanger() { 8 | } 9 | 10 | const char* TimeChanger::getRawModuleName() { 11 | return "TimeChanger"; 12 | } 13 | 14 | const char* TimeChanger::getModuleName() { 15 | if (modifier <= 0.24 || modifier >= 0.77) { 16 | name = std::string("TimeChanger ") + std::string(GRAY) + std::string("Day"); 17 | return name.c_str(); 18 | } 19 | if (modifier >= 0.24 || modifier <= 0.77) { 20 | name = std::string("TimeChanger ") + std::string(GRAY) + std::string("Night"); 21 | return name.c_str(); 22 | } 23 | } -------------------------------------------------------------------------------- /Packet/Module/Modules/TimeChanger.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../ModuleManager.h" 3 | #include "Module.h" 4 | 5 | class TimeChanger : public IModule { 6 | public: 7 | float modifier = 1.f; 8 | 9 | TimeChanger(); 10 | ~TimeChanger(); 11 | 12 | std::string name = ("TimeChanger"); 13 | 14 | // Inherited via IModule 15 | virtual const char* getModuleName() override; 16 | virtual const char* getRawModuleName() override; 17 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/Timer.cpp: -------------------------------------------------------------------------------- 1 | #include "Timer.h" 2 | 3 | Timer::Timer() : IModule(0, Category::PLAYER, "Modifies game speed") { 4 | this->registerIntSetting("TPS", &this->timer, this->timer, 5, 700); 5 | } 6 | 7 | Timer::~Timer() { 8 | } 9 | 10 | const char* Timer::getModuleName() { 11 | return ("Timer"); 12 | } 13 | 14 | void Timer::onTick(C_GameMode* gm) { 15 | if (timer) { 16 | *g_Data.getClientInstance()->minecraft->timer = static_cast(this->timer); 17 | } 18 | } 19 | 20 | void Timer::onDisable() { 21 | *g_Data.getClientInstance()->minecraft->timer = 20.f; 22 | } -------------------------------------------------------------------------------- /Packet/Module/Modules/Timer.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class Timer : public IModule { 4 | private: 5 | int timer = 50; 6 | 7 | public: 8 | Timer(); 9 | ~Timer(); 10 | 11 | // Inherited via IModule 12 | virtual const char* getModuleName() override; 13 | virtual void onDisable() override; 14 | virtual void onTick(C_GameMode* gm) override; 15 | }; 16 | -------------------------------------------------------------------------------- /Packet/Module/Modules/TriggerBot.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | #include "../ModuleManager.h" 4 | 5 | class TriggerBot : public IModule { 6 | private: 7 | bool hurttime = false; 8 | int delay = 0; 9 | int Odelay = 0; 10 | 11 | public: 12 | float range = 8; 13 | TriggerBot(); 14 | ~TriggerBot(); 15 | 16 | // Inherited via IModule 17 | virtual const char* getModuleName() override; 18 | virtual void onTick(C_GameMode* gm) override; 19 | }; 20 | -------------------------------------------------------------------------------- /Packet/Module/Modules/VanillaPlus.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class VanillaPlus : public IModule { 4 | 5 | public: 6 | bool fastFlyingItems = true; 7 | 8 | VanillaPlus(); 9 | virtual ~VanillaPlus(){}; 10 | 11 | virtual const char* getModuleName() override; 12 | virtual void onEnable() override; 13 | virtual void onDisable() override; 14 | virtual void onTick(C_GameMode*) override; 15 | }; 16 | -------------------------------------------------------------------------------- /Packet/Module/Modules/Velocity.cpp: -------------------------------------------------------------------------------- 1 | #include "Velocity.h" 2 | 3 | #include "../../Module/ModuleManager.h" 4 | 5 | Velocity::Velocity() : IModule(0, Category::MOVEMENT, "AntiKB Module") { 6 | registerFloatSetting("Linear", &xModifier, xModifier, 0.f, 1.f); 7 | registerFloatSetting("Height", &yModifier, yModifier, 0.f, 1.f); 8 | } 9 | 10 | Velocity::~Velocity() { 11 | } 12 | 13 | const char* Velocity::getRawModuleName() { 14 | return "Velocity"; 15 | } 16 | 17 | const char* Velocity::getModuleName() { 18 | name = std::string("Velocity ") + std::string(GRAY) + std::to_string((int)xModifier) + std::string(".") + std::to_string((int)(xModifier * 10) - ((int)xModifier * 10)); 19 | fullname = name + std::string("% ") + std::to_string((int)yModifier) + std::string(".") + std::to_string((int)(yModifier * 10) - ((int)yModifier * 10)) + std::string("%"); 20 | return fullname.c_str(); 21 | } 22 | 23 | void Velocity::onTick(C_GameMode* gm) { 24 | } -------------------------------------------------------------------------------- /Packet/Module/Modules/Velocity.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Module.h" 4 | 5 | class Velocity : public IModule { 6 | public: 7 | float xModifier = 0.f; 8 | float yModifier = 0.f; 9 | 10 | Velocity(); 11 | ~Velocity(); 12 | 13 | std::string name = "Velocity"; 14 | std::string fullname = "Velocity"; 15 | 16 | // Inherited via IModule 17 | virtual const char* getModuleName() override; 18 | virtual void onTick(C_GameMode* gm) override; 19 | virtual const char* getRawModuleName() override; 20 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/Watermark.cpp: -------------------------------------------------------------------------------- 1 | #include "Watermark.h" 2 | 3 | Watermark::Watermark() : IModule(0, Category::VISUAL, "goa frea thiom dsisti - deq") { 4 | registerBoolSetting("FirstLetter", &firstLetter, &firstLetter); 5 | registerEnumSetting("Theme", &mode, 0); 6 | mode.addEntry("Packet", 0); 7 | mode.addEntry("New", 1); 8 | //mode.addEntry("Fadeaway", 2); 9 | //mode.addEntry("Test", 3); 10 | registerFloatSetting("Opacity", &opacity, opacity, 0.f, 1.f); 11 | } 12 | 13 | Watermark::~Watermark() { 14 | } 15 | 16 | const char* Watermark::getModuleName() { 17 | return ("Watermark"); 18 | } 19 | 20 | void Watermark::onPostRender(C_MinecraftUIRenderContext* renderCtx) { 21 | } 22 | 23 | void Watermark::onTick(C_GameMode* gm) { 24 | } -------------------------------------------------------------------------------- /Packet/Module/Modules/Watermark.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../ModuleManager.h" 3 | #include "Module.h" 4 | 5 | class Watermark : public IModule { 6 | private: 7 | public: 8 | std::string message = "Packet Client"; 9 | inline std::string& getMessage() { return message; }; 10 | bool firstLetter = false; 11 | float opacity = 0.6f; 12 | 13 | Watermark(); 14 | ~Watermark(); 15 | 16 | SettingEnum mode = this; 17 | 18 | // Inherited via IModule 19 | virtual const char* getModuleName() override; 20 | virtual void onTick(C_GameMode* gm) override; 21 | virtual void onPostRender(C_MinecraftUIRenderContext* renderCtx) override; 22 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/XP.cpp: -------------------------------------------------------------------------------- 1 | #include "XP.h" 2 | 3 | XP::XP() : IModule(0, Category::PLAYER, "Gives you experience levels") { 4 | this->registerBoolSetting("Levels", &this->levels, this->levels); 5 | this->registerIntSetting("Amount", &this->amount, this->amount, 1, 250); 6 | } 7 | 8 | const char* XP::getModuleName() { 9 | return "XP"; 10 | } 11 | 12 | void XP::onTick(C_GameMode* gm) { 13 | auto player = g_Data.getLocalPlayer(); 14 | if (levels) { 15 | player->addLevels(amount); 16 | } else { 17 | player->addExperience(amount); 18 | } 19 | } -------------------------------------------------------------------------------- /Packet/Module/Modules/XP.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "Module.h" 4 | 5 | class XP : public IModule { 6 | private: 7 | bool levels = true; 8 | int amount = 1; 9 | 10 | public: 11 | XP(); 12 | 13 | virtual const char* getModuleName(); 14 | virtual void onTick(C_GameMode* gm) override; 15 | }; -------------------------------------------------------------------------------- /Packet/Module/Modules/Xray.cpp: -------------------------------------------------------------------------------- 1 | #include "Xray.h" 2 | 3 | Xray::Xray() : IModule(0, Category::VISUAL, "Allows you to see certain blocks easier") { 4 | } 5 | 6 | Xray::~Xray() { 7 | } 8 | 9 | const char* Xray::getModuleName() { 10 | return ("Xray"); 11 | } 12 | 13 | void Xray::onEnable() { 14 | if (smoothLightningSetting != nullptr) { 15 | if (!gotSmoothInfo) { 16 | gotSmoothInfo = true; 17 | wasSmooth = *smoothLightningSetting; 18 | } 19 | *smoothLightningSetting = 0; 20 | } 21 | } 22 | 23 | void Xray::onTick(C_GameMode* gm) { 24 | onEnable(); // yes lol 25 | } 26 | 27 | void Xray::onDisable() { 28 | if (smoothLightningSetting != nullptr && gotSmoothInfo) { 29 | *smoothLightningSetting = wasSmooth; 30 | } 31 | gotSmoothInfo = false; 32 | } -------------------------------------------------------------------------------- /Packet/Module/Modules/Xray.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class Xray : public IModule { 4 | public: 5 | bool* smoothLightningSetting = nullptr; 6 | bool gotSmoothInfo = false; 7 | bool wasSmooth = false; 8 | 9 | Xray(); 10 | ~Xray(); 11 | 12 | // Inherited via IModule 13 | virtual const char* getModuleName() override; 14 | virtual void onTick(C_GameMode* gm) override; 15 | virtual void onDisable() override; 16 | virtual void onEnable() override; 17 | }; 18 | -------------------------------------------------------------------------------- /Packet/Module/Modules/Zoom.cpp: -------------------------------------------------------------------------------- 1 | #include "Zoom.h" 2 | 3 | Zoom::Zoom() : IModule('C', Category::VISUAL, "Zoom in.") { 4 | registerFloatSetting("Strength", &this->strength, this->strength, 50.f, 100.f); 5 | //registerBoolSetting("Smooth", &this->smooth, this->smooth); 6 | } 7 | 8 | Zoom::~Zoom() { 9 | } 10 | 11 | bool Zoom::isFlashMode() { 12 | return true; 13 | } 14 | 15 | const char* Zoom::getModuleName() { 16 | return ("Zoom"); 17 | } 18 | 19 | void Zoom::onEnable() { 20 | zooming = true; 21 | } 22 | 23 | void Zoom::onDisable() { 24 | target = g_Data.fov; 25 | } 26 | -------------------------------------------------------------------------------- /Packet/Module/Modules/Zoom.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Module.h" 3 | class Zoom : public IModule { 4 | public: 5 | Zoom(); 6 | ~Zoom(); 7 | 8 | bool smooth = true; 9 | bool zooming = false; 10 | float strength = 65.f; 11 | float target = 65.f; 12 | float modifier = 65.f; 13 | 14 | // Inherited via IModule 15 | virtual bool isFlashMode() override; 16 | virtual const char* getModuleName() override; 17 | virtual void onEnable() override; 18 | virtual void onDisable() override; 19 | }; 20 | -------------------------------------------------------------------------------- /Packet/Scripting/Functions/CommandManagerFunctions.cpp: -------------------------------------------------------------------------------- 1 | #include "CommandManagerFunctions.h" 2 | 3 | JsValueRef CALLBACK CommandManagerFunctions::executeCommand(JsValueRef callee, bool isConstructCall, JsValueRef* arguments, unsigned short argumentCount, void* callbackState) { 4 | auto commandOpt = chakra.tryGetStringFromArgs(arguments[1], argumentCount - 1); 5 | if (!commandOpt.has_value()) { 6 | THROW(L"Invalid command specified"); 7 | } 8 | 9 | char* coolBeanBuffer = new char[commandOpt.value().size() + 2]; 10 | sprintf_s(coolBeanBuffer, commandOpt.value().size() + 2, ".%S", commandOpt.value().c_str()); 11 | cmdMgr->execute(coolBeanBuffer); 12 | delete[] coolBeanBuffer; 13 | 14 | return chakra.trueValue(); 15 | } -------------------------------------------------------------------------------- /Packet/Scripting/Functions/CommandManagerFunctions.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../ScriptManager.h" 4 | #include "../../Command/CommandMgr.h" 5 | 6 | class CommandManagerFunctions { 7 | public: 8 | DECL_FUN(executeCommand); 9 | }; 10 | -------------------------------------------------------------------------------- /Packet/Scripting/Functions/DrawFunctions.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../ScriptManager.h" 4 | 5 | class DrawFunctions { 6 | public: 7 | DECL_FUN(drawLine3d); 8 | DECL_FUN(setColor); 9 | DECL_FUN(drawLinestrip3d); 10 | DECL_FUN(drawLine2d); 11 | DECL_FUN(drawRectangle2d); 12 | DECL_FUN(fillRectangle2d); 13 | 14 | DECL_FUN(drawText2d); 15 | DECL_FUN(getTextWidth); 16 | DECL_FUN(getTextLineHeight); 17 | 18 | DECL_FUN(getWindowSize); 19 | DECL_FUN(getOrigin); 20 | }; 21 | -------------------------------------------------------------------------------- /Packet/Scripting/Functions/GameFunctions.cpp: -------------------------------------------------------------------------------- 1 | #include "GameFunctions.h" 2 | 3 | JsValueRef CALLBACK GameFunctions::getClient(JsValueRef callee, bool isConstructCall, JsValueRef* arguments, unsigned short argumentCount, void* callbackState) { 4 | std::wstring name(L"Packet"); 5 | JsValueRef ref; 6 | chakra.JsPointerToString_(name.c_str(), name.size(), &ref); 7 | return ref; 8 | } 9 | 10 | JsValueRef CALLBACK GameFunctions::getLocalPlayer(JsValueRef callee, bool isConstructCall, JsValueRef* arguments, unsigned short argumentCount, void* callbackState) { 11 | return scriptMgr.getLocalPlayer(reinterpret_cast(callbackState)); 12 | } 13 | 14 | JsValueRef CALLBACK GameFunctions::getLevel(JsValueRef callee, bool isConstructCall, JsValueRef* arguments, unsigned short argumentCount, void* callbackState) { 15 | return reinterpret_cast(callbackState)->levelObject; 16 | } -------------------------------------------------------------------------------- /Packet/Scripting/Functions/GameFunctions.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../ScriptManager.h" 4 | 5 | class GameFunctions { 6 | public: 7 | DECL_FUN(getClient); 8 | DECL_FUN(getLocalPlayer); 9 | DECL_FUN(getLevel); 10 | }; 11 | -------------------------------------------------------------------------------- /Packet/Scripting/Functions/GlobalFunctions.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../ScriptManager.h" 4 | #include "Vector3Functions.h" 5 | 6 | class GlobalFunctions { 7 | public: 8 | DECL_FUN(log); 9 | }; 10 | -------------------------------------------------------------------------------- /Packet/Scripting/Functions/HorionFunctions.cpp: -------------------------------------------------------------------------------- 1 | #include "HorionFunctions.h" 2 | 3 | JsValueRef CALLBACK HorionFunctions::getCommandManager(JsValueRef callee, bool isConstructCall, JsValueRef* arguments, unsigned short argumentCount, void* callbackState) { 4 | return reinterpret_cast(callbackState)->commandManager; 5 | } 6 | 7 | JsValueRef CALLBACK HorionFunctions::getModuleManager(JsValueRef callee, bool isConstructCall, JsValueRef* arguments, unsigned short argumentCount, void* callbackState) { 8 | return reinterpret_cast(callbackState)->moduleManager; 9 | } 10 | 11 | JsValueRef CALLBACK HorionFunctions::getDrawUtils(JsValueRef callee, bool isConstructCall, JsValueRef* arguments, unsigned short argumentCount, void* callbackState) { 12 | return reinterpret_cast(callbackState)->drawUtils; 13 | } -------------------------------------------------------------------------------- /Packet/Scripting/Functions/HorionFunctions.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../ScriptManager.h" 4 | 5 | class HorionFunctions { 6 | public: 7 | DECL_FUN(getCommandManager); 8 | DECL_FUN(getModuleManager); 9 | DECL_FUN(getDrawUtils); 10 | }; 11 | -------------------------------------------------------------------------------- /Packet/Scripting/Functions/InventoryFunctions.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../ScriptManager.h" 4 | 5 | class InventoryFunctions { 6 | public: 7 | DECL_FUN(getItems); 8 | DECL_FUN(getArmor); 9 | DECL_FUN(getHeld); 10 | DECL_FUN(getSlot); 11 | DECL_FUN(moveItem); 12 | DECL_FUN(setSelected); 13 | 14 | DECL_FUN(isFull); 15 | }; 16 | -------------------------------------------------------------------------------- /Packet/Scripting/Functions/LevelFunctions.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../ScriptManager.h" 4 | 5 | class LevelFunctions { 6 | public: 7 | DECL_FUN(isValid); 8 | DECL_FUN(getAllEntities); 9 | DECL_FUN(getAllTargetEntities); 10 | DECL_FUN(getBlock); 11 | }; 12 | -------------------------------------------------------------------------------- /Packet/Scripting/Functions/LocalPlayerFunctions.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../ScriptManager.h" 4 | #include "Vector3Functions.h" 5 | #include "InventoryFunctions.h" 6 | 7 | 8 | class LocalPlayerFunctions { 9 | public: 10 | DECL_FUN(setPosition); 11 | DECL_FUN(setVelocity); 12 | DECL_FUN(toString); 13 | DECL_FUN(setViewAngles); 14 | DECL_FUN(setIsOnGround); 15 | DECL_FUN(getInventory); 16 | DECL_FUN(breakBlock); 17 | DECL_FUN(placeBlock); 18 | DECL_FUN(breakBlockRelativeToPlr); 19 | DECL_FUN(placeBlockRelativeToPlr); 20 | }; 21 | -------------------------------------------------------------------------------- /Packet/Scripting/Functions/ModuleManagerFunctions.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../ScriptManager.h" 4 | 5 | class ModuleManagerFunctions { 6 | private: 7 | static std::optional> getModuleFromValue(JsValueRef); 8 | 9 | public: 10 | DECL_FUN(getModuleByName); 11 | DECL_FUN(registerModule); 12 | 13 | DECL_FUN(Module_getName); 14 | DECL_FUN(Module_toString); 15 | DECL_FUN(Module_isEnabled); 16 | DECL_FUN(Module_setEnabled); 17 | DECL_FUN(Module_toggle); 18 | 19 | DECL_FUN(JsModule_registerCallback); 20 | }; 21 | -------------------------------------------------------------------------------- /Packet/Scripting/Functions/Vector2Functions.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../../Utils/HMath.h" 4 | #include "../ScriptManager.h" 5 | #include 6 | 7 | class Vector2Functions { 8 | public: 9 | static std::optional getVec2FromValue(JsValueRef); 10 | static std::optional getVec2FromArguments(JsValueRef*, int argCount, int* nextArg = nullptr); 11 | 12 | DECL_FUN(isValid); 13 | DECL_FUN(getX); 14 | DECL_FUN(getY); 15 | DECL_FUN(toString); 16 | DECL_FUN(constructor); 17 | 18 | DECL_FUN(add); 19 | DECL_FUN(sub); 20 | DECL_FUN(div); 21 | DECL_FUN(mul); 22 | }; 23 | -------------------------------------------------------------------------------- /Packet/Scripting/Functions/Vector3Functions.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../../Utils/HMath.h" 4 | #include "../ScriptManager.h" 5 | #include 6 | 7 | class Vector3Functions { 8 | public: 9 | static std::optional getVec3FromValue(JsValueRef); 10 | static std::optional getVec3FromArguments(JsValueRef*, int argCount, int* nextArg = nullptr); 11 | 12 | DECL_FUN(isValid); 13 | DECL_FUN(getX); 14 | DECL_FUN(getY); 15 | DECL_FUN(getZ); 16 | DECL_FUN(toString); 17 | DECL_FUN(constructor); 18 | 19 | DECL_FUN(add); 20 | DECL_FUN(sub); 21 | DECL_FUN(div); 22 | DECL_FUN(mul); 23 | }; 24 | -------------------------------------------------------------------------------- /Packet/path/JoeConstants.cpp: -------------------------------------------------------------------------------- 1 | #include "JoeConstants.h" 2 | 3 | #include 4 | float distanceToTicks(float dist) { 5 | if(dist == 0) 6 | return 0; 7 | 8 | float tmp = dist; 9 | int tickCnt = 0; 10 | while(true){ 11 | float fallDist = minecraftFallVel(tickCnt); 12 | if(tmp <= fallDist){ 13 | return tickCnt + tmp / fallDist; 14 | } 15 | tmp -= fallDist; 16 | tickCnt++; 17 | } 18 | } 19 | float minecraftFallVel(int ticks) { 20 | return (powf(0.98f, (float)ticks) - 1) * -3.92f; 21 | } 22 | float* generateFallNBlocksCost() { 23 | float* costs = new float[257]; 24 | for(int i = 0; i < 257; i++){ 25 | costs[i] = distanceToTicks((float)i) * (1.f / 20); 26 | } 27 | return costs; 28 | } 29 | 30 | const float* FALL_N_BLOCKS_COST = generateFallNBlocksCost(); -------------------------------------------------------------------------------- /Packet/path/JoeConstants.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | constexpr float WALKING_SPEED = 4.32f; 4 | constexpr float SPRINT_SPEED = 5.61f; 5 | constexpr float WATER_SPEED = 1.8f; 6 | constexpr float JUMP_TIME = 0.6f; 7 | constexpr float PARKOUR_JUMP1_TIME = 0.5f; 8 | constexpr float WATER_UP_SPEED = 2.5f; 9 | constexpr float WATER_SINK_SPEED = 3.5f; 10 | 11 | float minecraftFallVel(int ticks); 12 | 13 | float distanceToTicks(float dist); 14 | 15 | float* generateFallNBlocksCost(); 16 | 17 | extern const float* FALL_N_BLOCKS_COST; -------------------------------------------------------------------------------- /Packet/path/JoeMovementController.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "JoePath.h" 4 | #include "../../SDK/CEntity.h" 5 | #include "../../SDK/CMoveInputHandler.h" 6 | 7 | class JoeMovementController { 8 | private: 9 | std::shared_ptr currentPath; 10 | struct { 11 | int currentPathSegment = 0; 12 | bool recoverToStartPos = false; 13 | 14 | void nextSegment(){ 15 | currentPathSegment++; 16 | recoverToStartPos = false; 17 | } 18 | } stateInfo; 19 | 20 | public: 21 | bool overrideViewAngles = false; 22 | vec2_t targetViewAngles = {0, 0}; 23 | 24 | JoeMovementController(std::shared_ptr path); 25 | 26 | void step(C_LocalPlayer* player, C_MoveInputHandler* movementHandler); 27 | bool isDone(){ 28 | return stateInfo.currentPathSegment >= currentPath->getNumSegments(); 29 | } 30 | int getCurrentPathSegment() const; 31 | const std::shared_ptr& getCurrentPath() const; 32 | }; 33 | -------------------------------------------------------------------------------- /Packet/path/JoePath.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include "JoeSegment.h" 5 | 6 | class JoePath { 7 | private: 8 | std::vector segments; 9 | bool isIncomplete; 10 | bool isInitialized = 0; 11 | public: 12 | JoePath(const std::vector& segments, bool isIncomplete); 13 | JoePath(); 14 | 15 | void cutoff(float percentageKeep); 16 | 17 | auto& getAllSegments(){ 18 | return segments; 19 | } 20 | size_t getNumSegments(){ 21 | return this->segments.size(); 22 | } 23 | auto getSegment(size_t seg){ 24 | return this->segments[seg]; 25 | } 26 | 27 | bool isInitialized1() const; 28 | void initPathSegments(); 29 | bool isIncomplete1() const; 30 | void draw(int) const; 31 | }; 32 | -------------------------------------------------------------------------------- /Packet/path/JoePathFinder.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Utils/HMath.h" 4 | #include "JoePath.h" 5 | #include "JoeSegment.h" 6 | #include "goals/JoeGoal.h" 7 | #include "../../SDK/CBlockLegacy.h" 8 | #include "JoeConstants.h" 9 | #include 10 | 11 | class JoePathFinder { 12 | private: 13 | vec3_ti startPos; 14 | JoePath currentPath; 15 | C_BlockSource* region; 16 | std::shared_ptr goal; 17 | public: 18 | bool terminateSearch = false; 19 | float pathSearchTimeout = 5.f; 20 | 21 | JoePathFinder(vec3_ti start, C_BlockSource* reg, std::shared_ptr goal); 22 | 23 | JoePath findPath(); 24 | const JoePath& getCurrentPath() const; 25 | }; 26 | -------------------------------------------------------------------------------- /Packet/path/JoeSegment.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../Utils/HMath.h" 4 | #include 5 | 6 | enum JoeSegmentType{ 7 | INVALID = -1, 8 | WALK = 0, 9 | JUMP, 10 | DROP, 11 | PARKOUR_JUMP_SINGLE, 12 | WATER_WALK 13 | }; 14 | 15 | class JoeSegment { 16 | private: 17 | JoeSegmentType segmentType; 18 | vec3_ti start, end; 19 | float cost; 20 | bool allowSprint; 21 | std::vector validPositions; 22 | public: 23 | JoeSegment(JoeSegmentType type, vec3_ti& start, vec3_ti& stop, float cost, bool allowSprint = false); 24 | void draw(); 25 | bool isAllowingSprint() const; 26 | void setAllowSprint(bool allowSprint); 27 | JoeSegmentType getSegmentType() const; 28 | const vec3_ti& getStart() const; 29 | const vec3_ti& getEnd() const; 30 | bool isInValidPosition(const vec3_ti& pos) const; 31 | void setValidPositions(const std::vector& validPositions); 32 | float getCost() const; 33 | void init(); 34 | }; 35 | -------------------------------------------------------------------------------- /Packet/path/goals/JoeGoal.cpp: -------------------------------------------------------------------------------- 1 | #include "JoeGoal.h" 2 | JoeGoal::~JoeGoal() { 3 | } 4 | -------------------------------------------------------------------------------- /Packet/path/goals/JoeGoal.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../../Utils/HMath.h" 4 | 5 | class JoeGoal { 6 | private: 7 | public: 8 | virtual ~JoeGoal(); 9 | 10 | virtual bool isInGoal(vec3_ti pos) = 0; 11 | virtual float getHeuristicEstimation(vec3_ti pos) = 0; 12 | }; 13 | -------------------------------------------------------------------------------- /Packet/path/goals/JoeGoalXYZ.cpp: -------------------------------------------------------------------------------- 1 | #include "JoeGoalXYZ.h" 2 | bool JoeGoalXYZ::isInGoal(vec3_ti pos) { 3 | return pos == targetPos; 4 | } 5 | float JoeGoalXYZ::getHeuristicEstimation(vec3_ti pos) { 6 | return JoeGoalXZ::heuristicEstimation(pos, targetPos) + JoeGoalY::heuristicEstimation(pos, (float)targetPos.y); 7 | } 8 | JoeGoalXYZ::JoeGoalXYZ(const vec3_ti& targetPos) : targetPos(targetPos) {} 9 | -------------------------------------------------------------------------------- /Packet/path/goals/JoeGoalXYZ.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "JoeGoal.h" 4 | #include "JoeGoalY.h" 5 | #include "JoeGoalXZ.h" 6 | 7 | class JoeGoalXYZ : public JoeGoal { 8 | private: 9 | vec3_ti targetPos; 10 | public: 11 | JoeGoalXYZ(const vec3_ti& targetPos); 12 | 13 | bool isInGoal(vec3_ti pos) override; 14 | float getHeuristicEstimation(vec3_ti pos) override; 15 | }; 16 | -------------------------------------------------------------------------------- /Packet/path/goals/JoeGoalXZ.cpp: -------------------------------------------------------------------------------- 1 | #include "JoeGoalXZ.h" 2 | 3 | #include "../JoeConstants.h" 4 | 5 | bool JoeGoalXZ::isInGoal(vec3_ti pos) { 6 | return pos.x == targetPos.x && pos.z == targetPos.z; 7 | } 8 | float JoeGoalXZ::getHeuristicEstimation(vec3_ti pos) { 9 | return JoeGoalXZ::heuristicEstimation(targetPos, pos); 10 | } 11 | float JoeGoalXZ::heuristicEstimation(vec3_ti node, vec3_ti target) { 12 | vec3_ti diff = node.sub(target); 13 | int x = abs(diff.x); 14 | int z = abs(diff.z); 15 | float straight; 16 | float diagonal; 17 | if (x < z) { 18 | straight = (float)z - x; 19 | diagonal = (float)x; 20 | } else { 21 | straight = (float)x - z; 22 | diagonal = (float)z; 23 | } 24 | static const float SQRT_2 = sqrtf(2); 25 | diagonal *= SQRT_2; 26 | return (straight + diagonal) / SPRINT_SPEED; 27 | } 28 | JoeGoalXZ::JoeGoalXZ(const vec3_ti& targetPos) : targetPos(targetPos) {} 29 | -------------------------------------------------------------------------------- /Packet/path/goals/JoeGoalXZ.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "JoeGoal.h" 4 | 5 | class JoeGoalXZ : public JoeGoal{ 6 | private: 7 | vec3_ti targetPos; 8 | public: 9 | JoeGoalXZ(const vec3_ti& targetPos); 10 | 11 | bool isInGoal(vec3_ti pos) override; 12 | float getHeuristicEstimation(vec3_ti pos) override; 13 | 14 | static float heuristicEstimation(vec3_ti node, vec3_ti target); 15 | }; 16 | -------------------------------------------------------------------------------- /Packet/path/goals/JoeGoalY.cpp: -------------------------------------------------------------------------------- 1 | #include "JoeGoalY.h" 2 | 3 | #include "../JoeConstants.h" 4 | 5 | JoeGoalY::JoeGoalY(float target) : target(target) {} 6 | bool JoeGoalY::isInGoal(vec3_ti pos) { 7 | return pos.y == target; 8 | } 9 | float JoeGoalY::getHeuristicEstimation(vec3_ti pos) { 10 | return heuristicEstimation(pos, target); 11 | } 12 | float JoeGoalY::heuristicEstimation(vec3_ti node, float target) { 13 | if(node.y > target) 14 | return FALL_N_BLOCKS_COST[(int)floorf(node.y - target)] * 0.99f; 15 | if(target > node.y) 16 | return (target - node.y) * JUMP_TIME * 0.99f; 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /Packet/path/goals/JoeGoalY.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "JoeGoal.h" 4 | 5 | class JoeGoalY : public JoeGoal { 6 | private: 7 | float target; 8 | public: 9 | JoeGoalY(float target); 10 | 11 | bool isInGoal(vec3_ti pos) override; 12 | float getHeuristicEstimation(vec3_ti pos) override; 13 | 14 | static float heuristicEstimation(vec3_ti node, float target); 15 | }; 16 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 |

2 | 3 |

4 | 5 | # Info 6 | Packet Client is an MCBE Utility mod made by: Packet and Deq 7 | Packet Client is a fork of the Horion Client 8 | 9 | 10 | ## Credits 11 | 12 | The original Horion developers 13 | 14 | Turakan - Original TargetHUD & LowHop 15 | 16 | 12brendon34 - Injector 17 | 18 | Founder - Very cool dood 19 | -------------------------------------------------------------------------------- /SDK/CCamera.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../Utils/HMath.h" 4 | 5 | class C_Camera { 6 | private: 7 | char pad_0000[128]; //0x0000 8 | public: 9 | bool renderPlayerModel; //0x0080 10 | bool renderFirstPersonObjects; //0x0081 11 | private: 12 | char pad_0082[26]; //0x0082 13 | public: 14 | float fov; //0x009C 15 | float nearClippingPlane; //0x00A0 16 | float farClippingPlane; //0x00A4 17 | private: 18 | char pad_00A8[104]; //0x00A8 19 | public: 20 | bool facesPlayerFront; //0x0110 21 | 22 | void getForwardVector(vec3_t*); 23 | void getEulerAngles(vec3_t*); 24 | void getPlayerRotation(vec2_t*); 25 | void setOrientation(float pitch, float yaw, float roll); 26 | void setOrientationDeg(float pitch, float yaw, float roll) { 27 | setOrientation((-yaw - 180) * RAD_DEG, -pitch * RAD_DEG, roll * RAD_DEG); 28 | } 29 | }; 30 | 31 | class C_CameraManager { 32 | public: 33 | C_Camera* getCameraOrDebugCamera(); 34 | }; -------------------------------------------------------------------------------- /SDK/CChestBlockActor.cpp: -------------------------------------------------------------------------------- 1 | #include "CChestBlockActor.h" 2 | 3 | #include "../Utils/Utils.h" 4 | 5 | bool C_ChestBlockActor::isBarrelBlock() { 6 | GamerTextHolder alloc; 7 | Utils::CallVFunc<25, void, GamerTextHolder*, __int64>(this, &alloc, 0); 8 | return strcmp(alloc.getText(), "container.barrel") == 0; 9 | } 10 | bool C_ChestBlockActor::isShulkerBlock() { 11 | GamerTextHolder alloc; 12 | Utils::CallVFunc<25, void, GamerTextHolder*, __int64>(this, &alloc, 0); 13 | return strcmp(alloc.getText(), "container.shulker") == 0; 14 | } 15 | AABB C_ChestBlockActor::getObstructionAABB() { 16 | void* coolPtr = malloc(sizeof(AABB) + 4); 17 | Utils::CallVFunc<40, void, void*>(this, coolPtr); 18 | AABB ret = *reinterpret_cast(coolPtr); 19 | free(coolPtr); 20 | return ret; 21 | } -------------------------------------------------------------------------------- /SDK/CClientInstanceScreenModel.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../Utils/Utils.h" 4 | 5 | class C_ClientInstanceScreenModel { 6 | public: 7 | void sendChatMessage(char* message) { 8 | using sendChatMessage = void(__fastcall*)(void*, char*); 9 | static sendChatMessage sendChatMessageFunc = reinterpret_cast(FindSignature("56 57 41 54 41 55 41 56 41 57 48 8D AC 24 ?? ?? ?? ?? 48 81 EC ?? ?? ?? ?? 48 C7 45 D8 ?? ?? ?? ?? 48 89 9C 24 ?? ?? ?? ?? 48 8B 05 ?? ?? ?? ?? 48 33 C4 48 89 85 ?? ?? ?? ?? 48 89 54 24 ??") - 2); 10 | 11 | if (sendChatMessageFunc != 0x0) 12 | sendChatMessageFunc(this, (char*)std::string(message).c_str()); 13 | } 14 | }; 15 | -------------------------------------------------------------------------------- /SDK/CGameMode.cpp: -------------------------------------------------------------------------------- 1 | #include "CGameMode.h" 2 | #include "../Memory/GameData.h" 3 | 4 | void C_GameMode::survivalDestroyBlockHack(vec3_ti const &block, int face, bool &isDestroyedOut, bool isFirst) { 5 | auto p = this->player; 6 | p->swing(); 7 | if (isFirst) 8 | this->startDestroyBlock(block, face, isDestroyedOut); 9 | else { 10 | *reinterpret_cast(reinterpret_cast<__int64>(p) + 0x1c5a) = 1; 11 | this->continueDestroyBlock(block, face, isDestroyedOut); 12 | } 13 | 14 | p->startDestroying(); 15 | 16 | // prevents regular code from aborting block-break 17 | *reinterpret_cast(reinterpret_cast<__int64>(p) + 0x1c5a) = 0; 18 | 19 | C_PlayerActionPacket action; 20 | action.action = 18; 21 | action.blockPosition = vec3_ti(block.x, block.y, block.z); 22 | action.face = face; 23 | action.entityRuntimeId = p->entityRuntimeId; 24 | g_Data.getClientInstance()->loopbackPacketSender->sendToServer(&action); 25 | } 26 | -------------------------------------------------------------------------------- /SDK/CGameSettingsInput.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class C_GameSettingsInput { 4 | private: 5 | char pad_0x0000[0x3E0]; //0x0000 6 | public: 7 | int* spaceBarKey; //0x3E0 8 | private: 9 | char pad_0x370[0x38]; //0x3E8 10 | public: 11 | int* sneakKey; //0x420 12 | private: 13 | char pad_0x0428[0x78]; //0x0428 14 | public: 15 | int* leftKey; //0x4A0 16 | private: 17 | char pad_0x418[0x38]; //0x4A8 18 | public: 19 | int* rightKey; //0x4E0 20 | private: 21 | char pad_0x450[0x38]; //0x4E8 22 | public: 23 | int* backKey; //0x520 24 | private: 25 | char pad_0x488[0x38]; //0x528 26 | public: 27 | int* forwardKey; //0x560 28 | }; 29 | -------------------------------------------------------------------------------- /SDK/CHIDController.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class C_HIDController { 4 | private: 5 | char pad_0x0000[0x50]; //0x0000 6 | public: 7 | union { 8 | struct { 9 | bool leftClickDown; //0x0050 10 | bool rightClickDown; //0x0051 11 | bool wheelDown; //0x0052 12 | bool mouse4Down; //0x0053 13 | bool mouse5Down; //0x0054 14 | }; 15 | bool clickMap[5]; 16 | }; 17 | }; 18 | -------------------------------------------------------------------------------- /SDK/CImageBuffer.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class CBlob { 4 | public: 5 | void* data; 6 | size_t size; 7 | }; -------------------------------------------------------------------------------- /SDK/CLoopbackPacketSender.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "CPacket.h" 4 | 5 | class C_LoopbackPacketSender { 6 | public: 7 | virtual ~C_LoopbackPacketSender(); 8 | virtual __int64 send(C_Packet* packet); 9 | virtual __int64 sendToServer(C_Packet* packet); 10 | virtual __int64 sendToClient(const void* networkIdentifier, const C_Packet* packet, int a4); 11 | virtual __int64 sendBroadcast(const C_Packet* packet); 12 | virtual __int64 sendBroadcast(const void* networkIdentifier, int a3, const C_Packet* packet); 13 | virtual __int64 flush(void* networkIdentifier, int a3); 14 | }; 15 | -------------------------------------------------------------------------------- /SDK/CMinecraftUIRenderContext.cpp: -------------------------------------------------------------------------------- 1 | #include "CMinecraftUIRenderContext.h" 2 | #include "../Utils/Utils.h" 3 | #include "../Utils/HMath.h" 4 | 5 | C_TexturePtr* C_MinecraftUIRenderContext::getTexture(C_TexturePtr* ptr, C_FilePath& path) { 6 | using getTexture_t = C_TexturePtr*(__fastcall*)(C_MinecraftUIRenderContext*,C_TexturePtr*,C_FilePath&,int); 7 | getTexture_t getTextureF = reinterpret_cast(FindSignature("48 89 54 24 ?? 53 48 83 EC ?? 48 ?? ?? ?? ?? ?? ?? ?? ?? 48 8B DA 49 83 78 ?? ?? 75 1C 33 C0 48 89 02 48 89 42 ?? 48 8D 4A ?? E8")); 8 | return getTextureF(this, ptr, path, 0); 9 | } 10 | -------------------------------------------------------------------------------- /SDK/CMoveInputHandler.cpp: -------------------------------------------------------------------------------- 1 | #include "CMoveInputHandler.h" 2 | #include "../Utils/Utils.h" 3 | 4 | __int64 C_MoveInputHandler::clearMovementState() { 5 | return Utils::CallVFunc<4, __int64>(this); 6 | } 7 | -------------------------------------------------------------------------------- /SDK/CMoveInputHandler.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class C_MoveInputHandler { 4 | private: 5 | char pad_0x0000[0x8]; //0x0000 6 | public: 7 | float sideMovement; //0x0008 8 | float forwardMovement; //0x000C 9 | private: 10 | char pad_0x0010[0x39]; //0x0010 11 | public: 12 | unsigned char isSneakDown; //0x0049 13 | private: 14 | char pad_0x004A[0x5]; //0x004A 15 | public: 16 | unsigned char isJumping; //0x004F 17 | unsigned char autoJumpInWater; //0x0050 18 | private: 19 | char pad_0x0051[0xE]; //0x0051 20 | public: 21 | bool forward; //0x005F 22 | bool backward; //0x0060 23 | bool left; //0x0061 24 | bool right; //0x0062 25 | private: 26 | char pad_0x0063[0x2D]; //0x0063 27 | public: 28 | __int64 clearMovementState();; 29 | }; 30 | -------------------------------------------------------------------------------- /SDK/MatrixStack.cpp: -------------------------------------------------------------------------------- 1 | #include "MatrixStack.h" 2 | 3 | MatrixStackRef::~MatrixStackRef() { 4 | this->stack->pop(); 5 | } 6 | -------------------------------------------------------------------------------- /SDK/MatrixStack.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | class MatrixStack; 7 | 8 | class MatrixStackRef { 9 | private: 10 | MatrixStack* stack; 11 | glm::mat4x4& myPtr; 12 | 13 | public: 14 | MatrixStackRef(MatrixStack* st, glm::mat4x4& top) : stack(st), myPtr(top){}; 15 | ~MatrixStackRef(); 16 | 17 | auto& operator->() { 18 | return myPtr; 19 | } 20 | auto& operator*() { 21 | return myPtr; 22 | } 23 | }; 24 | 25 | class MatrixStack { 26 | private: 27 | std::deque stack; 28 | bool isDirty; 29 | 30 | public: 31 | MatrixStackRef push() { 32 | this->isDirty = 1; 33 | const auto latestAndGreatest = this->stack.back(); 34 | this->stack.push_back(latestAndGreatest); 35 | return MatrixStackRef(this, this->stack.back()); 36 | } 37 | 38 | void pop() { 39 | this->isDirty = 1; 40 | this->stack.pop_back(); 41 | } 42 | 43 | glm::mat4x4& top() { 44 | return this->stack.back(); 45 | } 46 | }; -------------------------------------------------------------------------------- /SDK/Tessellator.cpp: -------------------------------------------------------------------------------- 1 | #include "Tessellator.h" 2 | 3 | #include "../Utils/Utils.h" 4 | #include "CBlockLegacy.h" 5 | #include "CClientInstance.h" 6 | 7 | void Tessellator::addPostTransformOffset(float x, float y, float z) { 8 | this->transformOffset = this->transformOffset.add(x, y, z); 9 | } 10 | 11 | mce::Mesh* BlockTessellator::getMeshForBlockInWorld(Tessellator *t, C_Block *block, vec3_ti &pos) { 12 | using BT_getMeshForBlockInWorld_t = mce::Mesh* (*)(BlockTessellator *, Tessellator *, C_Block *, vec3_ti &, int, __int64); 13 | static BT_getMeshForBlockInWorld_t getMeshForBlock = reinterpret_cast(FindSignature("40 55 53 56 57 41 54 41 55 41 56 41 57 48 8D AC 24 ?? ?? ?? ?? 48 81 EC ?? ?? ?? ?? 48 C7 44 24 ?? FE FF FF FF 48 8B 05 ?? ?? ?? ?? 48 33 C4 48 89 85 ?? ?? ?? ?? 4D 8B F1 4D 8B F8 48")); 14 | 15 | return getMeshForBlock(this, t, block, pos, block->getRenderLayer(), 0); 16 | } 17 | -------------------------------------------------------------------------------- /SDK/Tessellator.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../Utils/HMath.h" 4 | 5 | class Tessellator { 6 | private: 7 | char pad_0000[0x128]; 8 | vec3_t transformOffset; // 0x128 9 | 10 | public: 11 | void addPostTransformOffset(int x, int y, int z) { 12 | addPostTransformOffset((float)x, (float)y, (float)z); 13 | } 14 | void addPostTransformOffset(float x, float y, float z); 15 | }; 16 | 17 | class C_Block; 18 | 19 | namespace mce { 20 | class Mesh; 21 | } 22 | 23 | class BlockTessellator { 24 | public: 25 | mce::Mesh* getMeshForBlockInWorld(Tessellator * t, C_Block * block, vec3_ti & pos); 26 | }; -------------------------------------------------------------------------------- /SDK/Weather.h: -------------------------------------------------------------------------------- 1 | class Weather { 2 | private: 3 | char pad_0000[56]; //0x0000 4 | public: 5 | bool isRaining; //0x0038 6 | private: 7 | char pad_0039[11]; //0x0039 8 | public: 9 | bool isLightning; //0x0044 10 | private: 11 | char pad_0045[3]; //0x0045 12 | public: 13 | float lightningLevel; //0x0048 14 | }; -------------------------------------------------------------------------------- /Utils/DllHelper.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #ifndef WIN32_LEAN_AND_MEAN 4 | #define WIN32_LEAN_AND_MEAN 5 | #endif 6 | #include 7 | #include 8 | 9 | class ProcPtr { 10 | public: 11 | explicit ProcPtr(FARPROC ptr) : _ptr(ptr) {} 12 | 13 | template >> 14 | operator T*() const { 15 | return reinterpret_cast(_ptr); 16 | } 17 | 18 | private: 19 | FARPROC _ptr; 20 | }; 21 | 22 | class DllHelper { 23 | private: 24 | HMODULE _module; 25 | 26 | public: 27 | static HMODULE _parent_module; 28 | 29 | explicit DllHelper(LPCSTR filename) : _module(GetModuleHandleA(filename)) {} 30 | 31 | ~DllHelper() {} 32 | 33 | ProcPtr operator[](LPCSTR proc_name) const { 34 | return ProcPtr(GetProcAddress(_module, proc_name)); 35 | } 36 | }; -------------------------------------------------------------------------------- /Utils/Target.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include "../SDK/CEntity.h" 6 | 7 | class Target { 8 | private: 9 | static bool containsOnlyASCII(const std::string& string); 10 | 11 | public: 12 | static void init(C_LocalPlayer** lc); 13 | static bool isValidTarget(C_Entity* ent); 14 | }; 15 | -------------------------------------------------------------------------------- /Utils/TextFormat.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | extern void initColor(char* variable, char color); 6 | 7 | extern void init(); 8 | 9 | extern char BASE_CHARACTER[2]; 10 | extern char BLACK[4]; 11 | extern char DARK_BLUE[4]; 12 | extern char DARK_GREEN[4]; 13 | extern char DARK_AQUA[4]; 14 | extern char DARK_RED[4]; 15 | extern char DARK_PURPLE[4]; 16 | extern char GOLD[4]; 17 | extern char GRAY[4]; 18 | extern char DARK_GRAY[4]; 19 | extern char BLUE[4]; 20 | extern char GREEN[4]; 21 | extern char AQUA[4]; 22 | extern char RED[4]; 23 | extern char LIGHT_PURPLE[4]; 24 | extern char YELLOW[4]; 25 | extern char WHITE[4]; 26 | 27 | extern char OBFUSCATED[4]; 28 | extern char BOLD[4]; 29 | extern char STRIKETHROUGH[4]; 30 | extern char UNDERLINE[4]; 31 | extern char ITALIC[4]; 32 | extern char RESET[4]; 33 | -------------------------------------------------------------------------------- /Utils/VoxelIntersector.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "HMath.h" 4 | 5 | namespace Voxel { 6 | 7 | typedef struct { 8 | float x; 9 | float y; 10 | float z; 11 | } Point3; 12 | 13 | typedef struct { 14 | Point3 v1; /* Vertex1 */ 15 | Point3 v2; /* Vertex2 */ 16 | Point3 v3; /* Vertex3 */ 17 | } Triangle3; 18 | 19 | void getBoundingBox(AABB& aabbOut, const Triangle3& tri); 20 | bool intersects(const vec3_t& voxel, const Triangle3& triangle); 21 | } -------------------------------------------------------------------------------- /assets/images/logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacketDeveloper/Packet-Source/6b86a27d9c4af265fe1cde877736976870184665/assets/images/logo.png -------------------------------------------------------------------------------- /include/glm/.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files 2 | *.slo 3 | *.lo 4 | *.o 5 | *.obj 6 | 7 | # Precompiled Headers 8 | *.gch 9 | *.pch 10 | 11 | # Compiled Dynamic libraries 12 | *.so 13 | *.dylib 14 | *.dll 15 | 16 | # Fortran module files 17 | *.mod 18 | 19 | # Compiled Static libraries 20 | *.lai 21 | *.la 22 | *.a 23 | *.lib 24 | 25 | # Executables 26 | *.exe 27 | *.out 28 | *.app 29 | 30 | # CMake 31 | CMakeCache.txt 32 | CMakeFiles 33 | cmake_install.cmake 34 | install_manifest.txt 35 | *.cmake 36 | !glmConfig.cmake 37 | !glmConfig-version.cmake 38 | # ^ May need to add future .cmake files as exceptions 39 | 40 | # Test logs 41 | Testing/* 42 | 43 | # Test input 44 | test/gtc/*.dds 45 | 46 | # Project Files 47 | Makefile 48 | *.cbp 49 | *.user 50 | 51 | # Misc. 52 | *.log 53 | 54 | # local build(s) 55 | build* 56 | 57 | /.vs 58 | /.vscode 59 | /CMakeSettings.json 60 | .DS_Store 61 | *.swp 62 | -------------------------------------------------------------------------------- /include/glm/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.2 FATAL_ERROR) 2 | cmake_policy(VERSION 3.2) 3 | 4 | set(GLM_VERSION "0.9.9") 5 | project(glm VERSION ${GLM_VERSION} LANGUAGES CXX) 6 | enable_testing() 7 | 8 | add_subdirectory(glm) 9 | add_library(glm::glm ALIAS glm) 10 | 11 | if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR}) 12 | 13 | add_subdirectory(test) 14 | 15 | endif(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR}) 16 | -------------------------------------------------------------------------------- /include/glm/cmake/glm/glmConfig-version.cmake: -------------------------------------------------------------------------------- 1 | if(${PACKAGE_FIND_VERSION_MAJOR} EQUAL 0) 2 | if (${PACKAGE_FIND_VERSION} VERSION_LESS ${GLM_VERSION}) 3 | set(PACKAGE_VERSION_COMPATIBLE 1) 4 | endif() 5 | if(${PACKAGE_FIND_VERSION} VERSION_EQUAL ${GLM_VERSION}) 6 | set(PACKAGE_VERSION_EXACT 1) 7 | endif() 8 | else() 9 | set(PACKAGE_VERSION_UNSUITABLE 1) 10 | endif() 11 | 12 | -------------------------------------------------------------------------------- /include/glm/cmake/glm/glmConfig.cmake: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.2 FATAL_ERROR) 2 | cmake_policy(VERSION 3.2) 3 | 4 | set(GLM_VERSION 0.9.9) 5 | 6 | get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) 7 | get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) 8 | get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) 9 | if (_IMPORT_PREFIX STREQUAL "/") 10 | set(_IMPORT_PREFIX "") 11 | endif() 12 | 13 | # Set the old GLM_INCLUDE_DIRS variable for backwards compatibility 14 | set(GLM_INCLUDE_DIRS ${_IMPORT_PREFIX}) 15 | 16 | add_library(glm::glm INTERFACE IMPORTED) 17 | set_target_properties(glm::glm PROPERTIES 18 | INTERFACE_INCLUDE_DIRECTORIES ${GLM_INCLUDE_DIRS}) 19 | 20 | mark_as_advanced(glm_DIR) 21 | set(_IMPORT_PREFIX) 22 | 23 | -------------------------------------------------------------------------------- /include/glm/glm/detail/_fixes.hpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | //! Workaround for compatibility with other libraries 4 | #ifdef max 5 | #undef max 6 | #endif 7 | 8 | //! Workaround for compatibility with other libraries 9 | #ifdef min 10 | #undef min 11 | #endif 12 | 13 | //! Workaround for Android 14 | #ifdef isnan 15 | #undef isnan 16 | #endif 17 | 18 | //! Workaround for Android 19 | #ifdef isinf 20 | #undef isinf 21 | #endif 22 | 23 | //! Workaround for Chrone Native Client 24 | #ifdef log2 25 | #undef log2 26 | #endif 27 | 28 | -------------------------------------------------------------------------------- /include/glm/glm/detail/compute_vector_relational.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | //#include "compute_common.hpp" 4 | #include "setup.hpp" 5 | #include 6 | 7 | namespace glm{ 8 | namespace detail 9 | { 10 | template 11 | struct compute_equal 12 | { 13 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(T a, T b) 14 | { 15 | return a == b; 16 | } 17 | }; 18 | /* 19 | template 20 | struct compute_equal 21 | { 22 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR static bool call(T a, T b) 23 | { 24 | return detail::compute_abs::is_signed>::call(b - a) <= static_cast(0); 25 | //return std::memcmp(&a, &b, sizeof(T)) == 0; 26 | } 27 | }; 28 | */ 29 | }//namespace detail 30 | }//namespace glm 31 | -------------------------------------------------------------------------------- /include/glm/glm/detail/func_packing_simd.inl: -------------------------------------------------------------------------------- 1 | namespace glm{ 2 | namespace detail 3 | { 4 | 5 | }//namespace detail 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /include/glm/glm/detail/func_trigonometric_simd.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacketDeveloper/Packet-Source/6b86a27d9c4af265fe1cde877736976870184665/include/glm/glm/detail/func_trigonometric_simd.inl -------------------------------------------------------------------------------- /include/glm/glm/detail/func_vector_relational_simd.inl: -------------------------------------------------------------------------------- 1 | namespace glm{ 2 | namespace detail 3 | { 4 | 5 | }//namespace detail 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /include/glm/glm/detail/type_half.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "setup.hpp" 4 | 5 | namespace glm{ 6 | namespace detail 7 | { 8 | typedef short hdata; 9 | 10 | GLM_FUNC_DECL float toFloat32(hdata value); 11 | GLM_FUNC_DECL hdata toFloat16(float const& value); 12 | 13 | }//namespace detail 14 | }//namespace glm 15 | 16 | #include "type_half.inl" 17 | -------------------------------------------------------------------------------- /include/glm/glm/detail/type_mat4x4_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | 3 | namespace glm 4 | { 5 | 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_common.inl: -------------------------------------------------------------------------------- 1 | #include "../matrix.hpp" 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER mat mix(mat const& x, mat const& y, U a) 7 | { 8 | return mat(x) * (static_cast(1) - a) + mat(y) * a; 9 | } 10 | 11 | template 12 | GLM_FUNC_QUALIFIER mat mix(mat const& x, mat const& y, mat const& a) 13 | { 14 | return matrixCompMult(mat(x), static_cast(1) - a) + matrixCompMult(mat(y), a); 15 | } 16 | }//namespace glm 17 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_double2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double2x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 2 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 2, double, defaultp> dmat2x2; 16 | 17 | /// 2 columns of 2 components matrix of double-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<2, 2, double, defaultp> dmat2; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_double2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double2x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 3 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 3, double, defaultp> dmat2x3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_double2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double2x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 4 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 4, double, defaultp> dmat2x4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_double3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double3x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 3 columns of 2 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 2, double, defaultp> dmat3x2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_double3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double3x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 3 columns of 3 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 3, double, defaultp> dmat3x3; 16 | 17 | /// 3 columns of 3 components matrix of double-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<3, 3, double, defaultp> dmat3; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_double3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double3x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 3 columns of 4 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 4, double, defaultp> dmat3x4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_double4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double4x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 2 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 2, double, defaultp> dmat4x2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_double4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double4x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 3 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 3, double, defaultp> dmat4x3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_double4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_double4x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 4 components matrix of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 4, double, defaultp> dmat4x4; 16 | 17 | /// 4 columns of 4 components matrix of double-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<4, 4, double, defaultp> dmat4; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_float2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float2x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 2 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 2, float, defaultp> mat2x2; 16 | 17 | /// 2 columns of 2 components matrix of single-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<2, 2, float, defaultp> mat2; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_float2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float2x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 3 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 3, float, defaultp> mat2x3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_float2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float2x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat2x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 2 columns of 4 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<2, 4, float, defaultp> mat2x4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_float3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float3x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core 10 | /// @{ 11 | 12 | /// 3 columns of 2 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 2, float, defaultp> mat3x2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_float3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float3x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 3 columns of 3 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 3, float, defaultp> mat3x3; 16 | 17 | /// 3 columns of 3 components matrix of single-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<3, 3, float, defaultp> mat3; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_float3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float3x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat3x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 3 columns of 4 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<3, 4, float, defaultp> mat3x4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_float4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float4x2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 2 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 2, float, defaultp> mat4x2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_float4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float4x3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 3 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 3, float, defaultp> mat4x3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_float4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/matrix_float4x4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_mat4x4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @ingroup core_matrix 10 | /// @{ 11 | 12 | /// 4 columns of 4 components matrix of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 15 | typedef mat<4, 4, float, defaultp> mat4x4; 16 | 17 | /// 4 columns of 4 components matrix of single-precision floating-point numbers. 18 | /// 19 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 20 | typedef mat<4, 4, float, defaultp> mat4; 21 | 22 | /// @} 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_int2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int2x3 2 | /// @file glm/ext/matrix_int2x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x3 GLM_EXT_matrix_int2x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int2x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int2x3 25 | /// @{ 26 | 27 | /// Signed integer 2x3 matrix. 28 | /// 29 | /// @see ext_matrix_int2x3 30 | typedef mat<2, 3, int, defaultp> imat2x3; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_int2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int2x4 2 | /// @file glm/ext/matrix_int2x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x4 GLM_EXT_matrix_int2x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int2x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int2x4 25 | /// @{ 26 | 27 | /// Signed integer 2x4 matrix. 28 | /// 29 | /// @see ext_matrix_int2x4 30 | typedef mat<2, 4, int, defaultp> imat2x4; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_int3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int3x2 2 | /// @file glm/ext/matrix_int3x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x2 GLM_EXT_matrix_int3x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int3x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int3x2 25 | /// @{ 26 | 27 | /// Signed integer 3x2 matrix. 28 | /// 29 | /// @see ext_matrix_int3x2 30 | typedef mat<3, 2, int, defaultp> imat3x2; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_int3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int3x4 2 | /// @file glm/ext/matrix_int3x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x4 GLM_EXT_matrix_int3x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int3x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int3x4 25 | /// @{ 26 | 27 | /// Signed integer 3x4 matrix. 28 | /// 29 | /// @see ext_matrix_int3x4 30 | typedef mat<3, 4, int, defaultp> imat3x4; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_int4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int4x2 2 | /// @file glm/ext/matrix_int4x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int4x2 GLM_EXT_matrix_int4x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int4x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int4x2 25 | /// @{ 26 | 27 | /// Signed integer 4x2 matrix. 28 | /// 29 | /// @see ext_matrix_int4x2 30 | typedef mat<4, 2, int, defaultp> imat4x2; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_int4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int4x3 2 | /// @file glm/ext/matrix_int4x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int4x3 GLM_EXT_matrix_int4x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int4x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int4x3 25 | /// @{ 26 | 27 | /// Signed integer 4x3 matrix. 28 | /// 29 | /// @see ext_matrix_int4x3 30 | typedef mat<4, 3, int, defaultp> imat4x3; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_uint2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint2x3 2 | /// @file glm/ext/matrix_uint2x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x3 GLM_EXT_matrix_uint2x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint2x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint2x3 25 | /// @{ 26 | 27 | /// Unsigned integer 2x3 matrix. 28 | /// 29 | /// @see ext_matrix_uint2x3 30 | typedef mat<2, 3, uint, defaultp> umat2x3; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_uint2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint2x4 2 | /// @file glm/ext/matrix_uint2x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint2x4 GLM_EXT_matrix_int2x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat2x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint2x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint2x4 25 | /// @{ 26 | 27 | /// Unsigned integer 2x4 matrix. 28 | /// 29 | /// @see ext_matrix_uint2x4 30 | typedef mat<2, 4, uint, defaultp> umat2x4; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_uint3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint3x2 2 | /// @file glm/ext/matrix_uint3x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x2 GLM_EXT_matrix_uint3x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint3x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint3x2 25 | /// @{ 26 | 27 | /// Unsigned integer 3x2 matrix. 28 | /// 29 | /// @see ext_matrix_uint3x2 30 | typedef mat<3, 2, uint, defaultp> umat3x2; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_uint3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint3x4 2 | /// @file glm/ext/matrix_uint3x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint3x4 GLM_EXT_matrix_uint3x4 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat3x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint3x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint3x4 25 | /// @{ 26 | 27 | /// Signed integer 3x4 matrix. 28 | /// 29 | /// @see ext_matrix_uint3x4 30 | typedef mat<3, 4, uint, defaultp> umat3x4; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_uint4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint4x2 2 | /// @file glm/ext/matrix_uint4x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint4x2 GLM_EXT_matrix_uint4x2 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint4x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint4x2 25 | /// @{ 26 | 27 | /// Unsigned integer 4x2 matrix. 28 | /// 29 | /// @see ext_matrix_uint4x2 30 | typedef mat<4, 2, uint, defaultp> umat4x2; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/glm/ext/matrix_uint4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint4x3 2 | /// @file glm/ext/matrix_uint4x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint4x3 GLM_EXT_matrix_uint4x3 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines a number of matrices with integer types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../mat4x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint4x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint4x3 25 | /// @{ 26 | 27 | /// Unsigned integer 4x3 matrix. 28 | /// 29 | /// @see ext_matrix_uint4x3 30 | typedef mat<4, 3, uint, defaultp> umat4x3; 31 | 32 | /// @} 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /include/glm/glm/ext/quaternion_common_simd.inl: -------------------------------------------------------------------------------- 1 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 2 | 3 | namespace glm{ 4 | namespace detail 5 | { 6 | template 7 | struct compute_dot, float, true> 8 | { 9 | static GLM_FUNC_QUALIFIER float call(qua const& x, qua const& y) 10 | { 11 | return _mm_cvtss_f32(glm_vec1_dot(x.data, y.data)); 12 | } 13 | }; 14 | }//namespace detail 15 | }//namespace glm 16 | 17 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 18 | 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/quaternion_transform.inl: -------------------------------------------------------------------------------- 1 | namespace glm 2 | { 3 | template 4 | GLM_FUNC_QUALIFIER qua rotate(qua const& q, T const& angle, vec<3, T, Q> const& v) 5 | { 6 | vec<3, T, Q> Tmp = v; 7 | 8 | // Axis of rotation must be normalised 9 | T len = glm::length(Tmp); 10 | if(abs(len - static_cast(1)) > static_cast(0.001)) 11 | { 12 | T oneOverLen = static_cast(1) / len; 13 | Tmp.x *= oneOverLen; 14 | Tmp.y *= oneOverLen; 15 | Tmp.z *= oneOverLen; 16 | } 17 | 18 | T const AngleRad(angle); 19 | T const Sin = sin(AngleRad * static_cast(0.5)); 20 | 21 | return q * qua(cos(AngleRad * static_cast(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin); 22 | } 23 | }//namespace glm 24 | 25 | -------------------------------------------------------------------------------- /include/glm/glm/ext/scalar_constants.inl: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType epsilon() 7 | { 8 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'epsilon' only accepts floating-point inputs"); 9 | return std::numeric_limits::epsilon(); 10 | } 11 | 12 | template 13 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType pi() 14 | { 15 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'pi' only accepts floating-point inputs"); 16 | return static_cast(3.14159265358979323846264338327950288); 17 | } 18 | 19 | template 20 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType cos_one_over_two() 21 | { 22 | return genType(0.877582561890372716130286068203503191); 23 | } 24 | } //namespace glm 25 | -------------------------------------------------------------------------------- /include/glm/glm/ext/scalar_packing.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_scalar_packing 2 | /// @file glm/ext/scalar_packing.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_scalar_packing GLM_EXT_scalar_packing 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// This extension provides a set of function to convert scalar values to packed 12 | /// formats. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../detail/qualifier.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_scalar_packing extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_scalar_packing 26 | /// @{ 27 | 28 | 29 | /// @} 30 | }// namespace glm 31 | 32 | #include "scalar_packing.inl" 33 | -------------------------------------------------------------------------------- /include/glm/glm/ext/scalar_packing.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacketDeveloper/Packet-Source/6b86a27d9c4af265fe1cde877736976870184665/include/glm/glm/ext/scalar_packing.inl -------------------------------------------------------------------------------- /include/glm/glm/ext/vector_bool1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_bool1 2 | /// @file glm/ext/vector_bool1.hpp 3 | /// 4 | /// @defgroup ext_vector_bool1 GLM_EXT_vector_bool1 5 | /// @ingroup ext 6 | /// 7 | /// Exposes bvec1 vector type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_bool1_precision extension. 12 | 13 | #pragma once 14 | 15 | #include "../detail/type_vec1.hpp" 16 | 17 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 18 | # pragma message("GLM: GLM_EXT_vector_bool1 extension included") 19 | #endif 20 | 21 | namespace glm 22 | { 23 | /// @addtogroup ext_vector_bool1 24 | /// @{ 25 | 26 | /// 1 components vector of boolean. 27 | typedef vec<1, bool, defaultp> bvec1; 28 | 29 | /// @} 30 | }//namespace glm 31 | -------------------------------------------------------------------------------- /include/glm/glm/ext/vector_bool2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_bool2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 2 components vector of boolean. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<2, bool, defaultp> bvec2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/vector_bool3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_bool3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 3 components vector of boolean. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<3, bool, defaultp> bvec3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/vector_bool4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_bool4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 4 components vector of boolean. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<4, bool, defaultp> bvec4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/vector_double1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_double1 2 | /// @file glm/ext/vector_double1.hpp 3 | /// 4 | /// @defgroup ext_vector_double1 GLM_EXT_vector_double1 5 | /// @ingroup ext 6 | /// 7 | /// Exposes double-precision floating point vector type with one component. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_double1_precision extension. 12 | /// @see ext_vector_float1 extension. 13 | 14 | #pragma once 15 | 16 | #include "../detail/type_vec1.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_vector_double1 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_vector_double1 25 | /// @{ 26 | 27 | /// 1 components vector of double-precision floating-point numbers. 28 | typedef vec<1, double, defaultp> dvec1; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /include/glm/glm/ext/vector_double2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_double2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 2 components vector of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<2, double, defaultp> dvec2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/vector_double3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_double3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 3 components vector of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<3, double, defaultp> dvec3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/vector_double4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_double4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 4 components vector of double-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<4, double, defaultp> dvec4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/vector_float1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_float1 2 | /// @file glm/ext/vector_float1.hpp 3 | /// 4 | /// @defgroup ext_vector_float1 GLM_EXT_vector_float1 5 | /// @ingroup ext 6 | /// 7 | /// Exposes single-precision floating point vector type with one component. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_float1_precision extension. 12 | /// @see ext_vector_double1 extension. 13 | 14 | #pragma once 15 | 16 | #include "../detail/type_vec1.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_vector_float1 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_vector_float1 25 | /// @{ 26 | 27 | /// 1 components vector of single-precision floating-point numbers. 28 | typedef vec<1, float, defaultp> vec1; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /include/glm/glm/ext/vector_float2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_float2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 2 components vector of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<2, float, defaultp> vec2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/vector_float3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_float3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 3 components vector of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<3, float, defaultp> vec3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/vector_float4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_float4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 4 components vector of single-precision floating-point numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<4, float, defaultp> vec4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/vector_int1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_int1 2 | /// @file glm/ext/vector_int1.hpp 3 | /// 4 | /// @defgroup ext_vector_int1 GLM_EXT_vector_int1 5 | /// @ingroup ext 6 | /// 7 | /// Exposes ivec1 vector type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_uint1 extension. 12 | /// @see ext_vector_int1_precision extension. 13 | 14 | #pragma once 15 | 16 | #include "../detail/type_vec1.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_vector_int1 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_vector_int1 25 | /// @{ 26 | 27 | /// 1 component vector of signed integer numbers. 28 | typedef vec<1, int, defaultp> ivec1; 29 | 30 | /// @} 31 | }//namespace glm 32 | 33 | -------------------------------------------------------------------------------- /include/glm/glm/ext/vector_int2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_int2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 2 components vector of signed integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<2, int, defaultp> ivec2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/vector_int3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_int3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 3 components vector of signed integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<3, int, defaultp> ivec3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/vector_int4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_int4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 4 components vector of signed integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<4, int, defaultp> ivec4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/vector_packing.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_packing 2 | /// @file glm/ext/vector_packing.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_vector_packing GLM_EXT_vector_packing 7 | /// @ingroup ext 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// This extension provides a set of function to convert vectors to packed 12 | /// formats. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../detail/qualifier.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_packing extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_packing 26 | /// @{ 27 | 28 | 29 | /// @} 30 | }// namespace glm 31 | 32 | #include "vector_packing.inl" 33 | -------------------------------------------------------------------------------- /include/glm/glm/ext/vector_packing.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacketDeveloper/Packet-Source/6b86a27d9c4af265fe1cde877736976870184665/include/glm/glm/ext/vector_packing.inl -------------------------------------------------------------------------------- /include/glm/glm/ext/vector_uint1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_uint1 2 | /// @file glm/ext/vector_uint1.hpp 3 | /// 4 | /// @defgroup ext_vector_uint1 GLM_EXT_vector_uint1 5 | /// @ingroup ext 6 | /// 7 | /// Exposes uvec1 vector type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_int1 extension. 12 | /// @see ext_vector_uint1_precision extension. 13 | 14 | #pragma once 15 | 16 | #include "../detail/type_vec1.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_vector_uint1 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_vector_uint1 25 | /// @{ 26 | 27 | /// 1 component vector of unsigned integer numbers. 28 | typedef vec<1, unsigned int, defaultp> uvec1; 29 | 30 | /// @} 31 | }//namespace glm 32 | 33 | -------------------------------------------------------------------------------- /include/glm/glm/ext/vector_uint2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_uint2.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 2 components vector of unsigned integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<2, unsigned int, defaultp> uvec2; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/vector_uint3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_uint3.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 3 components vector of unsigned integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<3, unsigned int, defaultp> uvec3; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/ext/vector_uint4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_uint4.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector 10 | /// @{ 11 | 12 | /// 4 components vector of unsigned integer numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | typedef vec<4, unsigned int, defaultp> uvec4; 16 | 17 | /// @} 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /include/glm/glm/gtc/matrix_transform.inl: -------------------------------------------------------------------------------- 1 | #include "../geometric.hpp" 2 | #include "../trigonometric.hpp" 3 | #include "../matrix.hpp" 4 | -------------------------------------------------------------------------------- /include/glm/glm/gtc/quaternion_simd.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacketDeveloper/Packet-Source/6b86a27d9c4af265fe1cde877736976870184665/include/glm/glm/gtc/quaternion_simd.inl -------------------------------------------------------------------------------- /include/glm/glm/gtc/type_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_precision 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /include/glm/glm/gtc/vec1.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_vec1 2 | /// @file glm/gtc/vec1.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_vec1 GLM_GTC_vec1 7 | /// @ingroup gtc 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Add vec1, ivec1, uvec1 and bvec1 types. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../ext/vector_bool1.hpp" 17 | #include "../ext/vector_bool1_precision.hpp" 18 | #include "../ext/vector_float1.hpp" 19 | #include "../ext/vector_float1_precision.hpp" 20 | #include "../ext/vector_double1.hpp" 21 | #include "../ext/vector_double1_precision.hpp" 22 | #include "../ext/vector_int1.hpp" 23 | #include "../ext/vector_int1_sized.hpp" 24 | #include "../ext/vector_uint1.hpp" 25 | #include "../ext/vector_uint1_sized.hpp" 26 | 27 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 28 | # pragma message("GLM: GLM_GTC_vec1 extension included") 29 | #endif 30 | 31 | -------------------------------------------------------------------------------- /include/glm/glm/gtx/exterior_product.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_exterior_product 2 | 3 | #include 4 | 5 | namespace glm { 6 | namespace detail 7 | { 8 | template 9 | struct compute_cross_vec2 10 | { 11 | GLM_FUNC_QUALIFIER static T call(vec<2, T, Q> const& v, vec<2, T, Q> const& u) 12 | { 13 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'cross' accepts only floating-point inputs"); 14 | 15 | return v.x * u.y - u.x * v.y; 16 | } 17 | }; 18 | }//namespace detail 19 | 20 | template 21 | GLM_FUNC_QUALIFIER T cross(vec<2, T, Q> const& x, vec<2, T, Q> const& y) 22 | { 23 | return detail::compute_cross_vec2::value>::call(x, y); 24 | } 25 | }//namespace glm 26 | 27 | -------------------------------------------------------------------------------- /include/glm/glm/gtx/float_notmalize.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_float_normalize 2 | 3 | #include 4 | 5 | namespace glm 6 | { 7 | template 8 | GLM_FUNC_QUALIFIER vec floatNormalize(vec const& v) 9 | { 10 | return vec(v) / static_cast(std::numeric_limits::max()); 11 | } 12 | 13 | }//namespace glm 14 | -------------------------------------------------------------------------------- /include/glm/glm/gtx/functions.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_functions 2 | 3 | #include "../exponential.hpp" 4 | 5 | namespace glm 6 | { 7 | template 8 | GLM_FUNC_QUALIFIER T gauss 9 | ( 10 | T x, 11 | T ExpectedValue, 12 | T StandardDeviation 13 | ) 14 | { 15 | return exp(-((x - ExpectedValue) * (x - ExpectedValue)) / (static_cast(2) * StandardDeviation * StandardDeviation)) / (StandardDeviation * sqrt(static_cast(6.28318530717958647692528676655900576))); 16 | } 17 | 18 | template 19 | GLM_FUNC_QUALIFIER T gauss 20 | ( 21 | vec<2, T, Q> const& Coord, 22 | vec<2, T, Q> const& ExpectedValue, 23 | vec<2, T, Q> const& StandardDeviation 24 | ) 25 | { 26 | vec<2, T, Q> const Squared = ((Coord - ExpectedValue) * (Coord - ExpectedValue)) / (static_cast(2) * StandardDeviation * StandardDeviation); 27 | return exp(-(Squared.x + Squared.y)); 28 | } 29 | }//namespace glm 30 | 31 | -------------------------------------------------------------------------------- /include/glm/glm/gtx/handed_coordinate_space.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_handed_coordinate_space 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER bool rightHanded 7 | ( 8 | vec<3, T, Q> const& tangent, 9 | vec<3, T, Q> const& binormal, 10 | vec<3, T, Q> const& normal 11 | ) 12 | { 13 | return dot(cross(normal, tangent), binormal) > T(0); 14 | } 15 | 16 | template 17 | GLM_FUNC_QUALIFIER bool leftHanded 18 | ( 19 | vec<3, T, Q> const& tangent, 20 | vec<3, T, Q> const& binormal, 21 | vec<3, T, Q> const& normal 22 | ) 23 | { 24 | return dot(cross(normal, tangent), binormal) < T(0); 25 | } 26 | }//namespace glm 27 | -------------------------------------------------------------------------------- /include/glm/glm/gtx/log_base.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_log_base 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER genType log(genType const& x, genType const& base) 7 | { 8 | return glm::log(x) / glm::log(base); 9 | } 10 | 11 | template 12 | GLM_FUNC_QUALIFIER vec log(vec const& x, vec const& base) 13 | { 14 | return glm::log(x) / glm::log(base); 15 | } 16 | }//namespace glm 17 | -------------------------------------------------------------------------------- /include/glm/glm/gtx/matrix_cross_product.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_cross_product 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> matrixCross3 7 | ( 8 | vec<3, T, Q> const& x 9 | ) 10 | { 11 | mat<3, 3, T, Q> Result(T(0)); 12 | Result[0][1] = x.z; 13 | Result[1][0] = -x.z; 14 | Result[0][2] = -x.y; 15 | Result[2][0] = x.y; 16 | Result[1][2] = x.x; 17 | Result[2][1] = -x.x; 18 | return Result; 19 | } 20 | 21 | template 22 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> matrixCross4 23 | ( 24 | vec<3, T, Q> const& x 25 | ) 26 | { 27 | mat<4, 4, T, Q> Result(T(0)); 28 | Result[0][1] = x.z; 29 | Result[1][0] = -x.z; 30 | Result[0][2] = -x.y; 31 | Result[2][0] = x.y; 32 | Result[1][2] = x.x; 33 | Result[2][1] = -x.x; 34 | return Result; 35 | } 36 | 37 | }//namespace glm 38 | -------------------------------------------------------------------------------- /include/glm/glm/gtx/matrix_factorisation.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacketDeveloper/Packet-Source/6b86a27d9c4af265fe1cde877736976870184665/include/glm/glm/gtx/matrix_factorisation.inl -------------------------------------------------------------------------------- /include/glm/glm/gtx/mixed_product.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_mixed_product 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER T mixedProduct 7 | ( 8 | vec<3, T, Q> const& v1, 9 | vec<3, T, Q> const& v2, 10 | vec<3, T, Q> const& v3 11 | ) 12 | { 13 | return dot(cross(v1, v2), v3); 14 | } 15 | }//namespace glm 16 | -------------------------------------------------------------------------------- /include/glm/glm/gtx/normal.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_normal 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER vec<3, T, Q> triangleNormal 7 | ( 8 | vec<3, T, Q> const& p1, 9 | vec<3, T, Q> const& p2, 10 | vec<3, T, Q> const& p3 11 | ) 12 | { 13 | return normalize(cross(p1 - p2, p1 - p3)); 14 | } 15 | }//namespace glm 16 | -------------------------------------------------------------------------------- /include/glm/glm/gtx/normalize_dot.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_normalize_dot 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER T normalizeDot(vec const& x, vec const& y) 7 | { 8 | return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y)); 9 | } 10 | 11 | template 12 | GLM_FUNC_QUALIFIER T fastNormalizeDot(vec const& x, vec const& y) 13 | { 14 | return glm::dot(x, y) * glm::fastInverseSqrt(glm::dot(x, x) * glm::dot(y, y)); 15 | } 16 | }//namespace glm 17 | -------------------------------------------------------------------------------- /include/glm/glm/gtx/number_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_number_precision 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /include/glm/glm/gtx/optimum_pow.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_optimum_pow 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER genType pow2(genType const& x) 7 | { 8 | return x * x; 9 | } 10 | 11 | template 12 | GLM_FUNC_QUALIFIER genType pow3(genType const& x) 13 | { 14 | return x * x * x; 15 | } 16 | 17 | template 18 | GLM_FUNC_QUALIFIER genType pow4(genType const& x) 19 | { 20 | return (x * x) * (x * x); 21 | } 22 | }//namespace glm 23 | -------------------------------------------------------------------------------- /include/glm/glm/gtx/orthonormalize.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_orthonormalize 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> orthonormalize(mat<3, 3, T, Q> const& m) 7 | { 8 | mat<3, 3, T, Q> r = m; 9 | 10 | r[0] = normalize(r[0]); 11 | 12 | T d0 = dot(r[0], r[1]); 13 | r[1] -= r[0] * d0; 14 | r[1] = normalize(r[1]); 15 | 16 | T d1 = dot(r[1], r[2]); 17 | d0 = dot(r[0], r[2]); 18 | r[2] -= r[0] * d0 + r[1] * d1; 19 | r[2] = normalize(r[2]); 20 | 21 | return r; 22 | } 23 | 24 | template 25 | GLM_FUNC_QUALIFIER vec<3, T, Q> orthonormalize(vec<3, T, Q> const& x, vec<3, T, Q> const& y) 26 | { 27 | return normalize(x - y * dot(y, x)); 28 | } 29 | }//namespace glm 30 | -------------------------------------------------------------------------------- /include/glm/glm/gtx/perpendicular.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_perpendicular 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER genType perp(genType const& x, genType const& Normal) 7 | { 8 | return x - proj(x, Normal); 9 | } 10 | }//namespace glm 11 | -------------------------------------------------------------------------------- /include/glm/glm/gtx/polar_coordinates.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_polar_coordinates 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER vec<3, T, Q> polar 7 | ( 8 | vec<3, T, Q> const& euclidean 9 | ) 10 | { 11 | T const Length(length(euclidean)); 12 | vec<3, T, Q> const tmp(euclidean / Length); 13 | T const xz_dist(sqrt(tmp.x * tmp.x + tmp.z * tmp.z)); 14 | 15 | return vec<3, T, Q>( 16 | asin(tmp.y), // latitude 17 | atan(tmp.x, tmp.z), // longitude 18 | xz_dist); // xz distance 19 | } 20 | 21 | template 22 | GLM_FUNC_QUALIFIER vec<3, T, Q> euclidean 23 | ( 24 | vec<2, T, Q> const& polar 25 | ) 26 | { 27 | T const latitude(polar.x); 28 | T const longitude(polar.y); 29 | 30 | return vec<3, T, Q>( 31 | cos(latitude) * sin(longitude), 32 | sin(latitude), 33 | cos(latitude) * cos(longitude)); 34 | } 35 | 36 | }//namespace glm 37 | -------------------------------------------------------------------------------- /include/glm/glm/gtx/projection.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_projection 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER genType proj(genType const& x, genType const& Normal) 7 | { 8 | return glm::dot(x, Normal) / glm::dot(Normal, Normal) * Normal; 9 | } 10 | }//namespace glm 11 | -------------------------------------------------------------------------------- /include/glm/glm/gtx/raw_data.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_raw_data 2 | 3 | -------------------------------------------------------------------------------- /include/glm/glm/gtx/std_based_type.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_std_based_type 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /include/glm/glm/gtx/texture.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_texture 2 | 3 | namespace glm 4 | { 5 | template 6 | inline T levels(vec const& Extent) 7 | { 8 | return glm::log2(compMax(Extent)) + static_cast(1); 9 | } 10 | 11 | template 12 | inline T levels(T Extent) 13 | { 14 | return vec<1, T, defaultp>(Extent).x; 15 | } 16 | }//namespace glm 17 | 18 | -------------------------------------------------------------------------------- /include/glm/glm/gtx/transform.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_transform 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> translate(vec<3, T, Q> const& v) 7 | { 8 | return translate(mat<4, 4, T, Q>(static_cast(1)), v); 9 | } 10 | 11 | template 12 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rotate(T angle, vec<3, T, Q> const& v) 13 | { 14 | return rotate(mat<4, 4, T, Q>(static_cast(1)), angle, v); 15 | } 16 | 17 | template 18 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> scale(vec<3, T, Q> const& v) 19 | { 20 | return scale(mat<4, 4, T, Q>(static_cast(1)), v); 21 | } 22 | 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /include/glm/glm/gtx/type_aligned.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_type_aligned 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /include/glm/glm/gtx/wrap.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_wrap 2 | 3 | namespace glm 4 | { 5 | 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /include/glm/glm/mat2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat2x2.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double2x2.hpp" 6 | #include "./ext/matrix_double2x2_precision.hpp" 7 | #include "./ext/matrix_float2x2.hpp" 8 | #include "./ext/matrix_float2x2_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /include/glm/glm/mat2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat2x3.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double2x3.hpp" 6 | #include "./ext/matrix_double2x3_precision.hpp" 7 | #include "./ext/matrix_float2x3.hpp" 8 | #include "./ext/matrix_float2x3_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /include/glm/glm/mat2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat2x4.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double2x4.hpp" 6 | #include "./ext/matrix_double2x4_precision.hpp" 7 | #include "./ext/matrix_float2x4.hpp" 8 | #include "./ext/matrix_float2x4_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /include/glm/glm/mat3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat3x2.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double3x2.hpp" 6 | #include "./ext/matrix_double3x2_precision.hpp" 7 | #include "./ext/matrix_float3x2.hpp" 8 | #include "./ext/matrix_float3x2_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /include/glm/glm/mat3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat3x3.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double3x3.hpp" 6 | #include "./ext/matrix_double3x3_precision.hpp" 7 | #include "./ext/matrix_float3x3.hpp" 8 | #include "./ext/matrix_float3x3_precision.hpp" 9 | -------------------------------------------------------------------------------- /include/glm/glm/mat3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat3x4.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double3x4.hpp" 6 | #include "./ext/matrix_double3x4_precision.hpp" 7 | #include "./ext/matrix_float3x4.hpp" 8 | #include "./ext/matrix_float3x4_precision.hpp" 9 | -------------------------------------------------------------------------------- /include/glm/glm/mat4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat4x2.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double4x2.hpp" 6 | #include "./ext/matrix_double4x2_precision.hpp" 7 | #include "./ext/matrix_float4x2.hpp" 8 | #include "./ext/matrix_float4x2_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /include/glm/glm/mat4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat4x3.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double4x3.hpp" 6 | #include "./ext/matrix_double4x3_precision.hpp" 7 | #include "./ext/matrix_float4x3.hpp" 8 | #include "./ext/matrix_float4x3_precision.hpp" 9 | -------------------------------------------------------------------------------- /include/glm/glm/mat4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat4x4.hpp 3 | 4 | #pragma once 5 | #include "./ext/matrix_double4x4.hpp" 6 | #include "./ext/matrix_double4x4_precision.hpp" 7 | #include "./ext/matrix_float4x4.hpp" 8 | #include "./ext/matrix_float4x4_precision.hpp" 9 | 10 | -------------------------------------------------------------------------------- /include/glm/glm/simd/exponential.h: -------------------------------------------------------------------------------- 1 | /// @ref simd 2 | /// @file glm/simd/experimental.h 3 | 4 | #pragma once 5 | 6 | #include "platform.h" 7 | 8 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 9 | 10 | GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec1_sqrt_lowp(glm_f32vec4 x) 11 | { 12 | return _mm_mul_ss(_mm_rsqrt_ss(x), x); 13 | } 14 | 15 | GLM_FUNC_QUALIFIER glm_f32vec4 glm_vec4_sqrt_lowp(glm_f32vec4 x) 16 | { 17 | return _mm_mul_ps(_mm_rsqrt_ps(x), x); 18 | } 19 | 20 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 21 | -------------------------------------------------------------------------------- /include/glm/glm/simd/packing.h: -------------------------------------------------------------------------------- 1 | /// @ref simd 2 | /// @file glm/simd/packing.h 3 | 4 | #pragma once 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 9 | -------------------------------------------------------------------------------- /include/glm/glm/simd/trigonometric.h: -------------------------------------------------------------------------------- 1 | /// @ref simd 2 | /// @file glm/simd/trigonometric.h 3 | 4 | #pragma once 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 9 | 10 | -------------------------------------------------------------------------------- /include/glm/glm/simd/vector_relational.h: -------------------------------------------------------------------------------- 1 | /// @ref simd 2 | /// @file glm/simd/vector_relational.h 3 | 4 | #pragma once 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 9 | -------------------------------------------------------------------------------- /include/glm/glm/vec2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/vec2.hpp 3 | 4 | #pragma once 5 | #include "./ext/vector_bool2.hpp" 6 | #include "./ext/vector_bool2_precision.hpp" 7 | #include "./ext/vector_float2.hpp" 8 | #include "./ext/vector_float2_precision.hpp" 9 | #include "./ext/vector_double2.hpp" 10 | #include "./ext/vector_double2_precision.hpp" 11 | #include "./ext/vector_int2.hpp" 12 | #include "./ext/vector_int2_sized.hpp" 13 | #include "./ext/vector_uint2.hpp" 14 | #include "./ext/vector_uint2_sized.hpp" 15 | -------------------------------------------------------------------------------- /include/glm/glm/vec3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/vec3.hpp 3 | 4 | #pragma once 5 | #include "./ext/vector_bool3.hpp" 6 | #include "./ext/vector_bool3_precision.hpp" 7 | #include "./ext/vector_float3.hpp" 8 | #include "./ext/vector_float3_precision.hpp" 9 | #include "./ext/vector_double3.hpp" 10 | #include "./ext/vector_double3_precision.hpp" 11 | #include "./ext/vector_int3.hpp" 12 | #include "./ext/vector_int3_sized.hpp" 13 | #include "./ext/vector_uint3.hpp" 14 | #include "./ext/vector_uint3_sized.hpp" 15 | -------------------------------------------------------------------------------- /include/glm/glm/vec4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/vec4.hpp 3 | 4 | #pragma once 5 | #include "./ext/vector_bool4.hpp" 6 | #include "./ext/vector_bool4_precision.hpp" 7 | #include "./ext/vector_float4.hpp" 8 | #include "./ext/vector_float4_precision.hpp" 9 | #include "./ext/vector_double4.hpp" 10 | #include "./ext/vector_double4_precision.hpp" 11 | #include "./ext/vector_int4.hpp" 12 | #include "./ext/vector_int4_sized.hpp" 13 | #include "./ext/vector_uint4.hpp" 14 | #include "./ext/vector_uint4_sized.hpp" 15 | 16 | -------------------------------------------------------------------------------- /include/glm/util/autoexp.txt: -------------------------------------------------------------------------------- 1 | [Visualizer] 2 | 3 | glm::detail::tvec2<*>{ 4 | preview ( 5 | #(#($c.x,$c.y)) 6 | ) 7 | children ( 8 | #([x]: $c.x,[y]: $c.y) 9 | ) 10 | } 11 | 12 | glm::detail::tvec3<*>{ 13 | preview ( 14 | #($e.x,$e.y,$e.z) 15 | ) 16 | children ( 17 | #([x]: $e.x,[y]: $e.y,[z]: $e.z) 18 | ) 19 | } 20 | 21 | glm::detail::tvec4<*>{ 22 | preview ( 23 | #($c.x,$c.y,$c.z,$c.w) 24 | ) 25 | children ( 26 | #([x]: $e.x,[y]: $e.y,[z]: $e.z, #([w]: $e.w)) 27 | ) 28 | } 29 | -------------------------------------------------------------------------------- /minhook/MinHook.x64.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacketDeveloper/Packet-Source/6b86a27d9c4af265fe1cde877736976870184665/minhook/MinHook.x64.lib -------------------------------------------------------------------------------- /packages.config: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | -------------------------------------------------------------------------------- /resource.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacketDeveloper/Packet-Source/6b86a27d9c4af265fe1cde877736976870184665/resource.h -------------------------------------------------------------------------------- /resources/Steve.dat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacketDeveloper/Packet-Source/6b86a27d9c4af265fe1cde877736976870184665/resources/Steve.dat -------------------------------------------------------------------------------- /resources/Steve_old.dat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacketDeveloper/Packet-Source/6b86a27d9c4af265fe1cde877736976870184665/resources/Steve_old.dat --------------------------------------------------------------------------------