├── diddlerInternal ├── TDObjects.cpp ├── thirdperson.cpp ├── glm │ ├── glm │ │ ├── ext │ │ │ ├── scalar_packing.inl │ │ │ ├── vector_packing.inl │ │ │ ├── quaternion_common_simd.inl │ │ │ ├── vector_bool2.hpp │ │ │ ├── vector_bool3.hpp │ │ │ ├── vector_bool4.hpp │ │ │ ├── vector_int2.hpp │ │ │ ├── vector_int3.hpp │ │ │ ├── vector_int4.hpp │ │ │ ├── vector_uint2.hpp │ │ │ ├── vector_uint3.hpp │ │ │ ├── vector_uint4.hpp │ │ │ ├── vector_float2.hpp │ │ │ ├── vector_float3.hpp │ │ │ ├── vector_float4.hpp │ │ │ ├── vector_double2.hpp │ │ │ ├── vector_double3.hpp │ │ │ ├── vector_double4.hpp │ │ │ ├── matrix_float3x2.hpp │ │ │ ├── matrix_float2x3.hpp │ │ │ ├── matrix_float2x4.hpp │ │ │ ├── matrix_float3x4.hpp │ │ │ ├── matrix_float4x2.hpp │ │ │ ├── matrix_float4x3.hpp │ │ │ ├── matrix_double2x3.hpp │ │ │ ├── matrix_double2x4.hpp │ │ │ ├── matrix_double3x2.hpp │ │ │ ├── matrix_double3x4.hpp │ │ │ ├── matrix_double4x2.hpp │ │ │ ├── matrix_double4x3.hpp │ │ │ ├── matrix_common.inl │ │ │ ├── quaternion_transform.inl │ │ │ ├── vector_bool1.hpp │ │ │ ├── matrix_float4x4.hpp │ │ │ ├── matrix_float2x2.hpp │ │ │ ├── matrix_float3x3.hpp │ │ │ ├── vector_packing.hpp │ │ │ ├── matrix_double2x2.hpp │ │ │ ├── matrix_double3x3.hpp │ │ │ ├── matrix_double4x4.hpp │ │ │ ├── scalar_constants.inl │ │ │ ├── scalar_packing.hpp │ │ │ ├── vector_int1.hpp │ │ │ ├── matrix_int2x3.hpp │ │ │ ├── matrix_int2x4.hpp │ │ │ ├── matrix_int3x2.hpp │ │ │ ├── matrix_int3x4.hpp │ │ │ ├── matrix_int4x2.hpp │ │ │ ├── matrix_int4x3.hpp │ │ │ ├── matrix_uint2x3.hpp │ │ │ ├── matrix_uint2x4.hpp │ │ │ ├── matrix_uint3x2.hpp │ │ │ ├── matrix_uint3x4.hpp │ │ │ ├── matrix_uint4x2.hpp │ │ │ ├── matrix_uint4x3.hpp │ │ │ ├── vector_uint1.hpp │ │ │ ├── vector_float1.hpp │ │ │ ├── vector_double1.hpp │ │ │ ├── matrix_int2x2.hpp │ │ │ ├── matrix_int3x3.hpp │ │ │ ├── matrix_int4x4.hpp │ │ │ ├── matrix_uint2x2.hpp │ │ │ ├── matrix_uint3x3.hpp │ │ │ ├── matrix_uint4x4.hpp │ │ │ ├── vector_bool1_precision.hpp │ │ │ ├── matrix_common.hpp │ │ │ ├── quaternion_float.hpp │ │ │ ├── quaternion_double.hpp │ │ │ ├── quaternion_trigonometric.inl │ │ │ ├── quaternion_relational.inl │ │ │ └── scalar_constants.hpp │ │ ├── gtc │ │ │ ├── quaternion_simd.inl │ │ │ ├── type_precision.inl │ │ │ ├── matrix_transform.inl │ │ │ ├── reciprocal.hpp │ │ │ ├── vec1.hpp │ │ │ ├── integer.inl │ │ │ └── integer.hpp │ │ ├── detail │ │ │ ├── func_trigonometric_simd.inl │ │ │ ├── type_mat4x4_simd.inl │ │ │ ├── func_packing_simd.inl │ │ │ ├── func_vector_relational_simd.inl │ │ │ ├── type_half.hpp │ │ │ ├── _fixes.hpp │ │ │ ├── compute_vector_relational.hpp │ │ │ └── func_exponential_simd.inl │ │ ├── gtx │ │ │ ├── raw_data.inl │ │ │ ├── wrap.inl │ │ │ ├── std_based_type.inl │ │ │ ├── type_aligned.inl │ │ │ ├── number_precision.inl │ │ │ ├── matrix_factorisation.inl │ │ │ ├── perpendicular.inl │ │ │ ├── projection.inl │ │ │ ├── mixed_product.inl │ │ │ ├── normal.inl │ │ │ ├── float_notmalize.inl │ │ │ ├── texture.inl │ │ │ ├── log_base.inl │ │ │ ├── optimum_pow.inl │ │ │ ├── normalize_dot.inl │ │ │ ├── handed_coordinate_space.inl │ │ │ ├── transform.inl │ │ │ ├── orthonormalize.inl │ │ │ ├── exterior_product.inl │ │ │ ├── matrix_cross_product.inl │ │ │ ├── functions.inl │ │ │ ├── polar_coordinates.inl │ │ │ ├── wrap.hpp │ │ │ ├── scalar_relational.hpp │ │ │ ├── gradient_paint.inl │ │ │ ├── extend.inl │ │ │ ├── normal.hpp │ │ │ └── mixed_product.hpp │ │ ├── simd │ │ │ ├── packing.h │ │ │ ├── vector_relational.h │ │ │ ├── trigonometric.h │ │ │ └── exponential.h │ │ ├── mat3x3.hpp │ │ ├── mat3x4.hpp │ │ ├── mat4x3.hpp │ │ ├── mat2x2.hpp │ │ ├── mat2x3.hpp │ │ ├── mat2x4.hpp │ │ ├── mat3x2.hpp │ │ ├── mat4x2.hpp │ │ ├── mat4x4.hpp │ │ ├── vec2.hpp │ │ ├── vec3.hpp │ │ └── vec4.hpp │ ├── test │ │ ├── bug │ │ │ ├── CMakeLists.txt │ │ │ └── bug_ms_vec_static.cpp │ │ ├── core │ │ │ ├── core_func_noise.cpp │ │ │ ├── core_func_trigonometric.cpp │ │ │ ├── core_force_aligned_gentypes.cpp │ │ │ ├── core_force_inline.cpp │ │ │ ├── core_force_left_handed.cpp │ │ │ ├── core_force_size_t_length.cpp │ │ │ ├── core_force_depth_zero_to_one.cpp │ │ │ ├── core_force_unrestricted_gentype.cpp │ │ │ ├── core_setup_force_cxx98.cpp │ │ │ ├── core_force_cxx03.cpp │ │ │ ├── core_force_cxx98.cpp │ │ │ ├── core_force_quat_wxyz.cpp │ │ │ ├── core_force_cxx_unknown.cpp │ │ │ ├── core_force_arch_unknown.cpp │ │ │ ├── core_force_compiler_unknown.cpp │ │ │ ├── core_force_platform_unknown.cpp │ │ │ ├── core_force_explicit_ctor.cpp │ │ │ ├── core_setup_force_size_t_length.cpp │ │ │ ├── core_setup_platform_unknown.cpp │ │ │ ├── core_type_int.cpp │ │ │ └── core_force_xyzw_only.cpp │ │ ├── gtc │ │ │ ├── gtc_quaternion.cpp │ │ │ ├── gtc_vec1.cpp │ │ │ ├── gtc_reciprocal.cpp │ │ │ ├── gtc_matrix_integer.cpp │ │ │ ├── gtc_constants.cpp │ │ │ ├── CMakeLists.txt │ │ │ └── gtc_user_defined_types.cpp │ │ ├── gtx │ │ │ ├── gtx.cpp │ │ │ ├── gtx_extend.cpp │ │ │ ├── gtx_normal.cpp │ │ │ ├── gtx_optimum_pow.cpp │ │ │ ├── gtx_projection.cpp │ │ │ ├── gtx_closest_point.cpp │ │ │ ├── gtx_normalize_dot.cpp │ │ │ ├── gtx_perpendicular.cpp │ │ │ ├── gtx_fast_exponential.cpp │ │ │ ├── gtx_number_precision.cpp │ │ │ ├── gtx_orthonormalize.cpp │ │ │ ├── gtx_color_space_YCoCg.cpp │ │ │ ├── gtx_polar_coordinates.cpp │ │ │ ├── gtx_vec_swizzle.cpp │ │ │ ├── gtx_matrix_cross_product.cpp │ │ │ ├── gtx_matrix_major_storage.cpp │ │ │ ├── gtx_matrix_transform_2d.cpp │ │ │ ├── gtx_handed_coordinate_space.cpp │ │ │ ├── gtx_rotate_normalized_axis.cpp │ │ │ ├── gtx_type_trait.cpp │ │ │ ├── gtx_associated_min_max.cpp │ │ │ ├── gtx_exterior_product.cpp │ │ │ ├── gtx_color_space.cpp │ │ │ ├── gtx_texture.cpp │ │ │ ├── gtx_matrix_decompose.cpp │ │ │ ├── gtx_compatibility.cpp │ │ │ ├── gtx_gradient_paint.cpp │ │ │ ├── gtx_int_10_10_10_2.cpp │ │ │ ├── gtx_mixed_product.cpp │ │ │ ├── gtx_functions.cpp │ │ │ └── gtx_scalar_multiplication.cpp │ │ ├── glm.cppcheck │ │ ├── cmake │ │ │ ├── CMakeLists.txt │ │ │ └── test_find_glm.cpp │ │ ├── perf │ │ │ └── CMakeLists.txt │ │ └── ext │ │ │ ├── ext_matrix_clip_space.cpp │ │ │ ├── ext_matrix_projection.cpp │ │ │ ├── ext_scalar_packing.cpp │ │ │ ├── ext_scalar_constants.cpp │ │ │ ├── ext_matrix_int2x3_sized.cpp │ │ │ ├── ext_matrix_int2x4_sized.cpp │ │ │ ├── ext_matrix_int3x2_sized.cpp │ │ │ ├── ext_matrix_int3x3_sized.cpp │ │ │ ├── ext_matrix_int4x2_sized.cpp │ │ │ ├── ext_matrix_int2x2_sized.cpp │ │ │ ├── ext_matrix_int3x4_sized.cpp │ │ │ ├── ext_matrix_int4x3_sized.cpp │ │ │ ├── ext_matrix_int4x4_sized.cpp │ │ │ ├── ext_matrix_uint2x2_sized.cpp │ │ │ ├── ext_matrix_uint2x3_sized.cpp │ │ │ ├── ext_matrix_uint2x4_sized.cpp │ │ │ ├── ext_matrix_uint3x2_sized.cpp │ │ │ ├── ext_matrix_uint3x3_sized.cpp │ │ │ ├── ext_matrix_uint3x4_sized.cpp │ │ │ ├── ext_matrix_uint4x2_sized.cpp │ │ │ ├── ext_matrix_uint4x3_sized.cpp │ │ │ ├── ext_matrix_uint4x4_sized.cpp │ │ │ ├── ext_quaternion_trigonometric.cpp │ │ │ ├── ext_vector_int1_sized.cpp │ │ │ ├── ext_vector_int4_sized.cpp │ │ │ ├── ext_vector_uint2_sized.cpp │ │ │ ├── ext_vector_int2_sized.cpp │ │ │ ├── ext_vector_int3_sized.cpp │ │ │ ├── ext_vector_uint3_sized.cpp │ │ │ ├── ext_vector_uint4_sized.cpp │ │ │ └── ext_vector_uint1_sized.cpp │ ├── cmake │ │ ├── glm │ │ │ ├── glmConfig-version.cmake │ │ │ └── glmConfig.cmake │ │ └── cmake_uninstall.cmake.in │ ├── util │ │ └── autoexp.txt │ └── .gitignore ├── thirdperson.h ├── TDFuncs.h ├── shapeHighlightManager.cpp ├── cutter.h ├── mainHook.h ├── glew32.dll ├── Jetpack.h ├── movementLoop.h ├── physMonitor.h ├── removeDownwardsVelocityLimit.h ├── Flamethrower.h ├── envOptions.h ├── missileLauncher.h ├── types.cpp ├── cameraManager.h ├── miscPatches.h ├── cutter.cpp ├── memhandler.h ├── tgtLeafblower.h ├── Harop.h ├── c4.h ├── focusHook.h ├── hookTests.h ├── tgtDev.h ├── tgtWire.h ├── tgtLeafblower.cpp ├── tgtRemove.h ├── godmode.h ├── Firespread.h ├── physCamera.h ├── memhandler.cpp ├── lidar.h ├── tgtBalloon.h ├── constClock.h ├── tgtFlamethrower.h ├── crashHandler.h ├── drawCube.h ├── tgtWire.cpp ├── tgtSlice.h ├── objectTranslationTest.h ├── shapeHightlightManager.h ├── removeDownwardsVelocityLimit.cpp ├── tgtDev.cpp ├── noclip.h ├── tgtMinigun.h ├── maths.h ├── swapBuffers.h ├── tgtDebug.h ├── tgtExplode.h ├── tgtCamera.h ├── wirePlacementBomb.h ├── wirePlacementGPS.h ├── wirePlacementLamp.h ├── wirePlacementIntBus.h ├── wirePlacementPower.h ├── tgtSpawner.h ├── wirePlacementBoolBus.h ├── wirePlacementConstInt.h ├── wirePlacementTemplate.h ├── Jetpack.cpp ├── tgtDamage.h ├── wirePlacementBalloonDeployer.h ├── wireTool.h ├── wirePlacementClock.h ├── wirePlacementButton.h ├── wirePlacementThruster.h ├── wirePlacementToggle.h ├── wireObjectKernel.h ├── wirePlacementPusher.h ├── wirePlacementRaycaster.h ├── tgtAttribute.h ├── tgtBalloon.cpp ├── balloons.h ├── Mods.h ├── resource.h ├── wirePlacementDelay.h ├── wirePlacementSpawner.h ├── tgtIncludes.h ├── lantern.h ├── console.h ├── tgtBase.h ├── wirePlacementRadio.h ├── tgtWeld.h ├── wirePlacementComparisons.h ├── wireObjectSpawn.h ├── miscPatches.cpp ├── mainHook.cpp ├── snapPoints.h ├── mem.h ├── dotProjector.h ├── godmode.cpp ├── tgtRope.h ├── movementLoop.cpp ├── wirePlacementTemplate.cpp ├── wirePlacements.h ├── tgtRemove.cpp ├── wirePlacementConstInt.cpp ├── wirePlacementGates.h ├── detver.h ├── focusHook.cpp ├── Raycaster.h ├── wirePlacementClock.cpp ├── wirePlacementBomb.cpp ├── wirePlacementButton.cpp └── tgtDamage.cpp ├── glew32.dll ├── knedmod.wsp └── README.md /diddlerInternal/TDObjects.cpp: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /diddlerInternal/thirdperson.cpp: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/ext/scalar_packing.inl: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/ext/vector_packing.inl: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/gtc/quaternion_simd.inl: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /diddlerInternal/thirdperson.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/detail/func_trigonometric_simd.inl: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /diddlerInternal/TDFuncs.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | void sigscanItems(); -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/gtx/raw_data.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_raw_data 2 | 3 | -------------------------------------------------------------------------------- /glew32.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nymda/knedmod/HEAD/glew32.dll -------------------------------------------------------------------------------- /diddlerInternal/glm/test/bug/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | glmCreateTestGTC(bug_ms_vec_static) 2 | -------------------------------------------------------------------------------- /diddlerInternal/shapeHighlightManager.cpp: -------------------------------------------------------------------------------- 1 | namespace highlightManager { 2 | 3 | } -------------------------------------------------------------------------------- /diddlerInternal/cutter.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | namespace cutter { 3 | void runCutter(); 4 | } 5 | -------------------------------------------------------------------------------- /diddlerInternal/mainHook.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | void initMainHook(); 3 | void terminateMainHook(); -------------------------------------------------------------------------------- /diddlerInternal/glew32.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nymda/knedmod/HEAD/diddlerInternal/glew32.dll -------------------------------------------------------------------------------- /diddlerInternal/Jetpack.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace jetpack { 4 | void executeJetpack(); 5 | } 6 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/gtc/type_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_precision 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/gtx/wrap.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_wrap 2 | 3 | namespace glm 4 | { 5 | 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /diddlerInternal/movementLoop.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | void terminateMovementHook(); 4 | void initMovementHook(); -------------------------------------------------------------------------------- /diddlerInternal/physMonitor.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace physMonitor { 4 | void spawnMonitor(); 5 | } -------------------------------------------------------------------------------- /diddlerInternal/removeDownwardsVelocityLimit.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | namespace rdvl { 3 | void enableRDVL(); 4 | } -------------------------------------------------------------------------------- /diddlerInternal/Flamethrower.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace flamethrower { 4 | void execFlamethrower(); 5 | } 6 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/gtx/std_based_type.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_std_based_type 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/gtx/type_aligned.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_type_aligned 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/gtx/number_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_number_precision 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/detail/type_mat4x4_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | 3 | namespace glm 4 | { 5 | 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/core/core_func_noise.cpp: -------------------------------------------------------------------------------- 1 | int main() 2 | { 3 | int Error = 0; 4 | 5 | return Error; 6 | } 7 | 8 | -------------------------------------------------------------------------------- /diddlerInternal/envOptions.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Global.h" 3 | 4 | namespace envOptions { 5 | 6 | void setNight(); 7 | } -------------------------------------------------------------------------------- /diddlerInternal/missileLauncher.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | namespace missile { 3 | void launchMissile(); 4 | void runMissile(); 5 | } -------------------------------------------------------------------------------- /diddlerInternal/types.cpp: -------------------------------------------------------------------------------- 1 | #include "Global.h" 2 | #include "types.h" 3 | #include "global.h" 4 | 5 | namespace td { 6 | 7 | 8 | } -------------------------------------------------------------------------------- /diddlerInternal/cameraManager.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace cameraManager { 4 | void takeCamera(); 5 | void returnCamera(); 6 | } -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtc/gtc_quaternion.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nymda/knedmod/HEAD/diddlerInternal/glm/test/gtc/gtc_quaternion.cpp -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int Error = 0; 6 | 7 | return Error; 8 | } 9 | -------------------------------------------------------------------------------- /diddlerInternal/miscPatches.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace miscPatches { 4 | extern bool plankPatch; 5 | void updatePlankPatch(); 6 | } -------------------------------------------------------------------------------- /diddlerInternal/cutter.cpp: -------------------------------------------------------------------------------- 1 | #include "Global.h" 2 | #include "raycaster.h" 3 | 4 | namespace cutter { 5 | void runCutter() { 6 | 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/detail/func_packing_simd.inl: -------------------------------------------------------------------------------- 1 | namespace glm{ 2 | namespace detail 3 | { 4 | 5 | }//namespace detail 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/gtc/matrix_transform.inl: -------------------------------------------------------------------------------- 1 | #include "../geometric.hpp" 2 | #include "../trigonometric.hpp" 3 | #include "../matrix.hpp" 4 | -------------------------------------------------------------------------------- /diddlerInternal/memhandler.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | uintptr_t containedMalloc(size_t size); 5 | void containedFree(void* mem); -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/gtx/matrix_factorisation.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nymda/knedmod/HEAD/diddlerInternal/glm/glm/gtx/matrix_factorisation.inl -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtc/gtc_vec1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int Error = 0; 6 | 7 | return Error; 8 | } 9 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/detail/func_vector_relational_simd.inl: -------------------------------------------------------------------------------- 1 | namespace glm{ 2 | namespace detail 3 | { 4 | 5 | }//namespace detail 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtc/gtc_reciprocal.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() 5 | { 6 | return 0; 7 | } 8 | 9 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtc/gtc_matrix_integer.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int Error = 0; 6 | 7 | return Error; 8 | } 9 | -------------------------------------------------------------------------------- /diddlerInternal/tgtLeafblower.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "tgtBase.h" 3 | 4 | struct tgt_leafblower : public tgt { 5 | tgt_leafblower(); 6 | DWORD exec() override; 7 | }; -------------------------------------------------------------------------------- /diddlerInternal/Harop.h: -------------------------------------------------------------------------------- 1 | //#pragma once 2 | // 3 | //namespace HaropDrone { 4 | // void spawnHarop(); 5 | // void destroyHarop(); 6 | // void updateHaropCamera(); 7 | // 8 | //} -------------------------------------------------------------------------------- /diddlerInternal/c4.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace c4 { 4 | extern int selectedBombSizeInt; 5 | extern float firecrackerExplosionSize; 6 | void runC4(); 7 | } 8 | -------------------------------------------------------------------------------- /diddlerInternal/focusHook.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace focusHook { 4 | void hkGetFocus(void* a1); 5 | void initFocusHook(); 6 | void terminateFocusHook(); 7 | } -------------------------------------------------------------------------------- /diddlerInternal/hookTests.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "TDFuncs.h" 3 | #include "types.h" 4 | #include "Global.h" 5 | 6 | void initTestHook(); 7 | 8 | void terminateTestHook(); -------------------------------------------------------------------------------- /diddlerInternal/tgtDev.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "tgtBase.h" 3 | 4 | struct tgt_dev : public tgt { 5 | bool spawnOnce = true; 6 | 7 | tgt_dev(); 8 | DWORD exec() override; 9 | }; -------------------------------------------------------------------------------- /diddlerInternal/tgtWire.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "tgtBase.h" 3 | #include "global.h" 4 | 5 | struct tgt_wire : public tgt { 6 | tgt_wire(); 7 | DWORD exec() override; 8 | }; -------------------------------------------------------------------------------- /diddlerInternal/glm/test/core/core_func_trigonometric.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int Error = 0; 6 | 7 | 8 | return Error; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /diddlerInternal/tgtLeafblower.cpp: -------------------------------------------------------------------------------- 1 | #include "tgtLeafblower.h" 2 | 3 | tgt_leafblower::tgt_leafblower() { 4 | 5 | } 6 | 7 | DWORD tgt_leafblower::exec() { 8 | 9 | return 0x01; 10 | } -------------------------------------------------------------------------------- /diddlerInternal/tgtRemove.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "tgtBase.h" 3 | 4 | struct tgt_remove : public tgt { 5 | bool spawnOnce = true; 6 | 7 | tgt_remove(); 8 | DWORD exec() override; 9 | }; -------------------------------------------------------------------------------- /diddlerInternal/glm/test/glm.cppcheck: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_extend.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | int main() 5 | { 6 | int Error(0); 7 | 8 | return Error; 9 | } 10 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_normal.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | int main() 5 | { 6 | int Error(0); 7 | 8 | return Error; 9 | } 10 | -------------------------------------------------------------------------------- /diddlerInternal/godmode.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "TDFuncs.h" 3 | #include "types.h" 4 | #include "Global.h" 5 | #include "Mods.h" 6 | 7 | void initGodmodeHook(); 8 | void terminateGodmodeHook(); -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/core/core_force_aligned_gentypes.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() 5 | { 6 | int Error = 0; 7 | 8 | return Error; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_optimum_pow.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | int main() 5 | { 6 | int Error(0); 7 | 8 | return Error; 9 | } 10 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_projection.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | int main() 5 | { 6 | int Error(0); 7 | 8 | return Error; 9 | } 10 | -------------------------------------------------------------------------------- /diddlerInternal/Firespread.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | namespace fireSpreadMod { 3 | extern bool isFireModEnabled; 4 | void toggleFireMod(); 5 | void enableEverythingBurns(); 6 | void disableEverythingBurns(); 7 | } -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_closest_point.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | int main() 5 | { 6 | int Error(0); 7 | 8 | return Error; 9 | } 10 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_normalize_dot.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | int main() 5 | { 6 | int Error(0); 7 | 8 | return Error; 9 | } 10 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_perpendicular.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | int main() 5 | { 6 | int Error(0); 7 | 8 | return Error; 9 | } 10 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_fast_exponential.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | int main() 5 | { 6 | int Error(0); 7 | 8 | return Error; 9 | } 10 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_number_precision.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | int main() 5 | { 6 | int Error(0); 7 | 8 | return Error; 9 | } 10 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_orthonormalize.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | int main() 5 | { 6 | int Error(0); 7 | 8 | return Error; 9 | } 10 | -------------------------------------------------------------------------------- /diddlerInternal/physCamera.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace physCamera { 4 | extern threadCamera::KMCamera* objCamera; 5 | void spawnCameraObject(); 6 | void updateCamera(); 7 | void destroyCamera(); 8 | } 9 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_color_space_YCoCg.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | int main() 5 | { 6 | int Error(0); 7 | 8 | return Error; 9 | } 10 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_polar_coordinates.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | int main() 5 | { 6 | int Error(0); 7 | 8 | return Error; 9 | } 10 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_vec_swizzle.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | int main() 5 | { 6 | int Error = 0; 7 | 8 | 9 | return Error; 10 | } 11 | 12 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_matrix_cross_product.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | int main() 5 | { 6 | int Error(0); 7 | 8 | return Error; 9 | } 10 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_matrix_major_storage.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | int main() 5 | { 6 | int Error(0); 7 | 8 | return Error; 9 | } 10 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_matrix_transform_2d.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | int main() 5 | { 6 | int Error(0); 7 | 8 | return Error; 9 | } 10 | -------------------------------------------------------------------------------- /diddlerInternal/memhandler.cpp: -------------------------------------------------------------------------------- 1 | #include "Global.h" 2 | 3 | uintptr_t containedMalloc(size_t size) { 4 | return glb::oTMalloc(size); 5 | } 6 | 7 | void containedFree(void* mem) { 8 | return glb::oTFree((uintptr_t)mem); 9 | } -------------------------------------------------------------------------------- /diddlerInternal/glm/test/core/core_force_inline.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_FORCE_INLINE 2 | 3 | #include 4 | #include 5 | 6 | int main() 7 | { 8 | int Error = 0; 9 | 10 | return Error; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_handed_coordinate_space.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | int main() 5 | { 6 | int Error(0); 7 | 8 | return Error; 9 | } 10 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_rotate_normalized_axis.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | int main() 5 | { 6 | int Error(0); 7 | 8 | return Error; 9 | } 10 | -------------------------------------------------------------------------------- /diddlerInternal/lidar.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace lidar { 4 | extern float zoom; 5 | extern bool colour; 6 | extern bool enabled; 7 | 8 | void nextFrame(); 9 | void drawLidarWindow(td::Vec2 size); 10 | } 11 | -------------------------------------------------------------------------------- /diddlerInternal/tgtBalloon.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "tgtBase.h" 3 | 4 | struct tgt_balloon : public tgt { 5 | float balloonPower = 10.f; 6 | bool spawnOnce = true; 7 | 8 | tgt_balloon(); 9 | DWORD exec() override; 10 | }; -------------------------------------------------------------------------------- /diddlerInternal/constClock.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | namespace constClock { 3 | void beginConstantClock(float pulseLengthMS); 4 | void endConstantClock(); 5 | void cUpdateThread(float msTime, bool* terminator); 6 | void cUpdateFunction(); 7 | } -------------------------------------------------------------------------------- /diddlerInternal/glm/test/core/core_force_left_handed.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_FORCE_LEFT_HANDED 2 | 3 | #include 4 | #include 5 | 6 | int main() 7 | { 8 | int Error = 0; 9 | 10 | return Error; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /diddlerInternal/tgtFlamethrower.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "tgtBase.h" 3 | 4 | struct tgt_flamethrower : public tgt { 5 | float flRadius = 5.f; 6 | int chance = 50; 7 | 8 | tgt_flamethrower(); 9 | DWORD exec() override; 10 | }; -------------------------------------------------------------------------------- /diddlerInternal/glm/test/core/core_force_size_t_length.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_FORCE_SIZE_T_LENGTH 2 | 3 | #include 4 | #include 5 | 6 | int main() 7 | { 8 | int Error = 0; 9 | 10 | return Error; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /diddlerInternal/crashHandler.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | namespace cHandler { 4 | extern int stageCode; 5 | int handleException(int code, PEXCEPTION_POINTERS ex); 6 | std::string createTextMemoryDump(byte* location, int size); 7 | } 8 | 9 | -------------------------------------------------------------------------------- /diddlerInternal/drawCube.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "types.h" 3 | #include "glm/glm.hpp" 4 | 5 | void drawCube(td::Vec3 position, float size, td::Color color); 6 | void drawCubeRotated(glm::vec3 position, glm::quat rotation, float size, td::Color color); -------------------------------------------------------------------------------- /diddlerInternal/glm/test/core/core_force_depth_zero_to_one.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_FORCE_DEPTH_ZERO_TO_ONE 2 | 3 | #include 4 | #include 5 | 6 | int main() 7 | { 8 | int Error = 0; 9 | 10 | return Error; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_type_trait.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | #include 4 | 5 | int main() 6 | { 7 | int Error = 0; 8 | 9 | 10 | 11 | return Error; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/core/core_force_unrestricted_gentype.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_FORCE_UNRESTRICTED_GENTYPE 2 | 3 | #include 4 | #include 5 | 6 | int main() 7 | { 8 | int Error = 0; 9 | 10 | return Error; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/core/core_setup_force_cxx98.cpp: -------------------------------------------------------------------------------- 1 | #ifndef GLM_FORCE_CXX98 2 | # define GLM_FORCE_CXX98 3 | #endif 4 | #include 5 | #include 6 | 7 | int main() 8 | { 9 | int Error = 0; 10 | 11 | return Error; 12 | } 13 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_associated_min_max.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | #include 4 | 5 | int main() 6 | { 7 | int Error(0); 8 | 9 | return Error; 10 | } 11 | -------------------------------------------------------------------------------- /diddlerInternal/tgtWire.cpp: -------------------------------------------------------------------------------- 1 | #include "tgtWire.h" 2 | #include "wireTool.h" 3 | 4 | tgt_wire::tgt_wire() { 5 | tool = TOOL_WIRE; 6 | } 7 | 8 | DWORD tgt_wire::exec() { 9 | wireObjects::execTool(); //wire tool is handled externally 10 | return 0x01; 11 | } -------------------------------------------------------------------------------- /diddlerInternal/glm/test/cmake/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.2 FATAL_ERROR) 2 | project(test_find_glm) 3 | 4 | find_package(glm REQUIRED) 5 | 6 | add_executable(test_find_glm test_find_glm.cpp) 7 | target_link_libraries(test_find_glm glm::glm) 8 | 9 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/core/core_force_cxx03.cpp: -------------------------------------------------------------------------------- 1 | #ifndef GLM_FORCE_CXX03 2 | # define GLM_FORCE_CXX03 3 | #endif 4 | 5 | #include 6 | #include 7 | 8 | int main() 9 | { 10 | int Error = 0; 11 | 12 | return Error; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/core/core_force_cxx98.cpp: -------------------------------------------------------------------------------- 1 | #ifndef GLM_FORCE_CXX98 2 | # define GLM_FORCE_CXX98 3 | #endif 4 | 5 | #include 6 | #include 7 | 8 | int main() 9 | { 10 | int Error = 0; 11 | 12 | return Error; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/core/core_force_quat_wxyz.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_FORCE_QUAT_DATA_WXYZ 2 | #define GLM_FORCE_INLINE 3 | 4 | #include 5 | #include 6 | 7 | int main() 8 | { 9 | int Error = 0; 10 | 11 | return Error; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /diddlerInternal/tgtSlice.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "tgtBase.h" 3 | 4 | struct tgt_slice: public tgt { 5 | float slicer_maxDist = 10.f; 6 | int slicer_resolution = 500; 7 | bool slicerHorizontal = true; 8 | 9 | tgt_slice(); 10 | DWORD exec() override; 11 | }; -------------------------------------------------------------------------------- /diddlerInternal/objectTranslationTest.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "objectSpawner.h" 3 | 4 | namespace objectTesting { 5 | extern spawner::KMSpawnedObject dbgObject; 6 | void spawnDebugObject(); 7 | void destroyDebugObject(); 8 | void updateDebugObject(); 9 | } 10 | -------------------------------------------------------------------------------- /diddlerInternal/shapeHightlightManager.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "TDObjects.h" 3 | 4 | namespace highlightManager { 5 | void pushShapeOutline(TDShape* shape, td::Color colour, int duration); 6 | void pushShapeHighlight(TDShape* shape, int duration); 7 | void update(); 8 | } -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/core/core_force_cxx_unknown.cpp: -------------------------------------------------------------------------------- 1 | #ifndef GLM_FORCE_CXX_UNKNOWN 2 | # define GLM_FORCE_CXX_UNKNOWN 3 | #endif 4 | 5 | #include 6 | #include 7 | 8 | int main() 9 | { 10 | int Error = 0; 11 | 12 | return Error; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/core/core_force_arch_unknown.cpp: -------------------------------------------------------------------------------- 1 | #ifndef GLM_FORCE_ARCH_UNKNOWN 2 | # define GLM_FORCE_ARCH_UNKNOWN 3 | #endif 4 | 5 | #include 6 | #include 7 | 8 | int main() 9 | { 10 | int Error = 0; 11 | 12 | return Error; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/perf/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | glmCreateTestGTC(perf_matrix_div) 2 | glmCreateTestGTC(perf_matrix_inverse) 3 | glmCreateTestGTC(perf_matrix_mul) 4 | glmCreateTestGTC(perf_matrix_mul_vector) 5 | glmCreateTestGTC(perf_matrix_transpose) 6 | glmCreateTestGTC(perf_vector_mul_matrix) 7 | -------------------------------------------------------------------------------- /diddlerInternal/removeDownwardsVelocityLimit.cpp: -------------------------------------------------------------------------------- 1 | #include "mem.h" 2 | #include "Global.h" 3 | 4 | namespace rdvl { 5 | //too lazy to do this with scanning, its only one function and its easy to find 6 | void enableRDVL() { 7 | //mem::Nop((byte*)(glb::moduleBase + 0x1214f5), 8); 8 | } 9 | } -------------------------------------------------------------------------------- /diddlerInternal/tgtDev.cpp: -------------------------------------------------------------------------------- 1 | #include "tgtDev.h" 2 | #include "balloons.h" 3 | #include "Global.h" 4 | #include "balloons.h" 5 | 6 | tgt_dev::tgt_dev() { 7 | 8 | } 9 | 10 | DWORD tgt_dev::exec() { 11 | 12 | if (glb::player->isAttacking) { 13 | 14 | } 15 | 16 | return 0x01; 17 | } -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/core/core_force_compiler_unknown.cpp: -------------------------------------------------------------------------------- 1 | #ifndef GLM_FORCE_COMPILER_UNKNOWN 2 | # define GLM_FORCE_COMPILER_UNKNOWN 3 | #endif 4 | 5 | #include 6 | #include 7 | 8 | int main() 9 | { 10 | int Error = 0; 11 | 12 | return Error; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/core/core_force_platform_unknown.cpp: -------------------------------------------------------------------------------- 1 | #ifndef GLM_FORCE_PLATFORM_UNKNOWN 2 | # define GLM_FORCE_PLATFORM_UNKNOWN 3 | #endif 4 | 5 | #include 6 | #include 7 | 8 | int main() 9 | { 10 | int Error = 0; 11 | 12 | return Error; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /diddlerInternal/noclip.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Global.h" 3 | #include "mem.h" 4 | 5 | namespace noclip { 6 | extern bool enabled; 7 | extern bool inNoclip; 8 | 9 | void setCameraEnabled(bool enable); 10 | 11 | void backupInstructions(); 12 | void ToggleNoclip(); 13 | void update(); 14 | } -------------------------------------------------------------------------------- /diddlerInternal/tgtMinigun.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "tgtBase.h" 3 | 4 | struct tgt_minigun : public tgt { 5 | 6 | int bulletCount = 5; 7 | float minigunFov = 2.f; 8 | int bulletType = 0; 9 | float u1 = 100.f; 10 | int u2 = 100; 11 | 12 | tgt_minigun(); 13 | DWORD exec() override; 14 | }; -------------------------------------------------------------------------------- /diddlerInternal/maths.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "types.h" 4 | 5 | td::Vec4 radianToQuaternion(double yaw, double pitch, double roll); 6 | td::Vec3 quat2euler(td::Vec4 quat, int rot, bool invert); 7 | td::Vec4 euler2quat(float x, float y, float z); 8 | td::Vec3 euler2otherEuler(td::Vec3 rot); -------------------------------------------------------------------------------- /diddlerInternal/swapBuffers.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "imgui/imgui.h" 3 | #include "imgui/imgui_impl_opengl3.h" 4 | #include "imgui/imgui_impl_win32.h" 5 | #include 6 | 7 | void initHIDsHook(); 8 | void initSwapBuffersHook(); 9 | void terminateHIDsHook(); 10 | void terminateSwapBuffersHook(); -------------------------------------------------------------------------------- /diddlerInternal/tgtDebug.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "tgtBase.h" 3 | #include "global.h" 4 | #include "imgui/imgui.h" 5 | 6 | struct tgt_debug: public tgt { 7 | TDShape* dbgShape = 0; 8 | TDBody* dbgBody = 0; 9 | ImGuiWindowFlags infoBoxFlags; 10 | 11 | tgt_debug(); 12 | DWORD exec() override; 13 | }; -------------------------------------------------------------------------------- /diddlerInternal/tgtExplode.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "tgtBase.h" 4 | #include "global.h" 5 | 6 | struct tgt_explode : public tgt { 7 | int bulletCount = 1; 8 | float explosionFov = 0.f; 9 | float explosionPower = 2.f; 10 | 11 | tgt_explode(); 12 | DWORD exec() override; 13 | }; -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/tgtCamera.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "tgtBase.h" 3 | #include "threadedCamera.h" 4 | 5 | struct tgt_camera : public tgt { 6 | threadCamera::KMCamera* playerCamera = 0; 7 | int resolutionX = 100; 8 | int resolutionY = 75; 9 | 10 | tgt_camera(); 11 | DWORD exec() override; 12 | void setResolution(); 13 | }; -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementBomb.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectBase.h" 3 | 4 | namespace wireObjects { 5 | class wirePlacementBomb : public wireObj { 6 | public: 7 | wirePlacementBomb(); 8 | DWORD init(TDShape* housing, int memoryVal) override; 9 | DWORD exec() override; 10 | DWORD usrExec() override; 11 | }; 12 | } -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementGPS.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectBase.h" 3 | 4 | namespace wireObjects { 5 | class wirePlacementGPS : public wireObj { 6 | public: 7 | wirePlacementGPS(); 8 | DWORD init(TDShape* housing, int memoryVal) override; 9 | DWORD exec() override; 10 | DWORD usrExec() override; 11 | }; 12 | } -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementLamp.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectBase.h" 3 | 4 | namespace wireObjects { 5 | class wirePlacementLamp : public wireObj { 6 | public: 7 | wirePlacementLamp(); 8 | DWORD init(TDShape* housing, int memoryVal) override; 9 | DWORD exec() override; 10 | DWORD usrExec() override; 11 | }; 12 | } -------------------------------------------------------------------------------- /diddlerInternal/glm/test/core/core_force_explicit_ctor.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_FORCE_EXPLICIT_CTOR 2 | 3 | #include 4 | #include 5 | 6 | int main() 7 | { 8 | int Error = 0; 9 | 10 | glm::ivec4 B(1); 11 | Error += B == glm::ivec4(1) ? 0 : 1; 12 | 13 | //glm::vec4 A = B; 14 | 15 | return Error; 16 | } 17 | 18 | -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementIntBus.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectBase.h" 3 | 4 | namespace wireObjects { 5 | class wirePlacementIntBus : public wireObj { 6 | public: 7 | wirePlacementIntBus(); 8 | DWORD init(TDShape* housing, int memoryVal) override; 9 | DWORD exec() override; 10 | DWORD usrExec() override; 11 | }; 12 | } -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementPower.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectBase.h" 3 | 4 | namespace wireObjects { 5 | class wirePlacementPower : public wireObj { 6 | public: 7 | wirePlacementPower(); 8 | DWORD init(TDShape* housing, int memoryVal) override; 9 | DWORD exec() override; 10 | DWORD usrExec() override; 11 | }; 12 | } -------------------------------------------------------------------------------- /diddlerInternal/tgtSpawner.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "tgtBase.h" 3 | #include "objectSpawner.h" 4 | 5 | struct tgt_spawner : public tgt { 6 | spawner::LoadedSpawnableObject currentSpawngunObject; 7 | bool spawnOnce = true; 8 | bool constSpawn = false; 9 | float throwPower = 5.f; 10 | 11 | tgt_spawner(); 12 | DWORD exec() override; 13 | }; -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementBoolBus.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectBase.h" 3 | 4 | namespace wireObjects { 5 | class wirePlacementBoolBus : public wireObj { 6 | public: 7 | wirePlacementBoolBus(); 8 | DWORD init(TDShape* housing, int memoryVal) override; 9 | DWORD exec() override; 10 | DWORD usrExec() override; 11 | }; 12 | } -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementConstInt.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectBase.h" 3 | 4 | namespace wireObjects { 5 | class wirePlacementConstInt : public wireObj { 6 | public: 7 | wirePlacementConstInt(); 8 | DWORD init(TDShape* housing, int memoryVal) override; 9 | DWORD exec() override; 10 | DWORD usrExec() override; 11 | }; 12 | } -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementTemplate.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectBase.h" 3 | 4 | namespace wireObjects { 5 | class wirePlacementTemplate : public wireObj { 6 | public: 7 | wirePlacementTemplate(); 8 | DWORD init(TDShape* housing, int memoryVal) override; 9 | DWORD exec() override; 10 | DWORD usrExec() override; 11 | }; 12 | } -------------------------------------------------------------------------------- /diddlerInternal/Jetpack.cpp: -------------------------------------------------------------------------------- 1 | #include "Global.h" 2 | #include "Raycaster.h" 3 | #include "objectSpawner.h" 4 | 5 | namespace jetpack { 6 | void executeJetpack() { 7 | 8 | if ((((GetAsyncKeyState(VK_SPACE) >> 15) & 0x0001) == 0x0001)) { 9 | if (glb::player->velocity.y < 15.f) { 10 | glb::player->velocity.y += 1.f; 11 | } 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /diddlerInternal/tgtDamage.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "tgtBase.h" 3 | 4 | struct tgt_damage : public tgt { 5 | float maxRange = 100.f; 6 | float holeSize = 0.2f; 7 | bool fireConst = true; 8 | bool fireOnceActive = true; 9 | int holesPerFrame = 10; 10 | float flRadius = 8.f; 11 | int res = 10; 12 | 13 | tgt_damage(); 14 | DWORD exec() override; 15 | }; -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementBalloonDeployer.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectBase.h" 3 | 4 | namespace wireObjects { 5 | class wirePlacementBalloonDeployer : public wireObj { 6 | public: 7 | wirePlacementBalloonDeployer(); 8 | DWORD init(TDShape* housing, int memoryVal) override; 9 | DWORD exec() override; 10 | DWORD usrExec() override; 11 | }; 12 | } -------------------------------------------------------------------------------- /diddlerInternal/wireTool.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectSpawn.h" 3 | 4 | namespace wireObjects { 5 | extern int targetUserMemory; 6 | 7 | enum class wireToolSetting { 8 | WTS_Interact, 9 | WTS_Place, 10 | WTS_SetUserMemory 11 | }; 12 | extern wireToolSetting toolgunSetting; 13 | extern wireObjectName toolgunSelectedObject; 14 | void execTool(); 15 | } -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementClock.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectBase.h" 3 | 4 | namespace wireObjects { 5 | class wirePlacementClock : public wireObj { 6 | public: 7 | int onTimeCountdown; 8 | 9 | wirePlacementClock(); 10 | DWORD init(TDShape* housing, int memoryVal) override; 11 | DWORD exec() override; 12 | DWORD usrExec() override; 13 | }; 14 | } -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementButton.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectBase.h" 3 | 4 | namespace wireObjects { 5 | class wirePlacementButton : public wireObj { 6 | public: 7 | int onTimeCountdown = 0; 8 | 9 | wirePlacementButton(); 10 | DWORD init(TDShape* housing, int memoryVal) override; 11 | DWORD exec() override; 12 | DWORD usrExec() override; 13 | }; 14 | } -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementThruster.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectBase.h" 3 | #include "objectSpawner.h" 4 | 5 | namespace wireObjects { 6 | class wirePlacementThruster : public wireObj { 7 | public: 8 | wirePlacementThruster(); 9 | DWORD init(TDShape* housing, int memoryVal) override; 10 | DWORD exec() override; 11 | DWORD usrExec() override; 12 | }; 13 | } -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementToggle.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectBase.h" 3 | 4 | namespace wireObjects { 5 | class wirePlacementToggle : public wireObj { 6 | public: 7 | bool previousInputState = false; 8 | wirePlacementToggle(); 9 | DWORD init(TDShape* housing, int memoryVal) override; 10 | DWORD exec() override; 11 | DWORD usrExec() override; 12 | }; 13 | } -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_exterior_product.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() 6 | { 7 | int Error = 0; 8 | 9 | float const f = glm::cross(glm::vec2(1.0f, 1.0f), glm::vec2(1.0f, 1.0f)); 10 | Error += glm::epsilonEqual(f, 0.0f, 0.001f) ? 0 : 1; 11 | 12 | return Error; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /diddlerInternal/wireObjectKernel.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectBase.h" 3 | #include "objectSpawner.h" 4 | #include 5 | 6 | namespace wireObjects { 7 | extern std::vector wireObjectStack; 8 | 9 | bool getWireObjectByShape(TDShape* shape, wireObj** out); 10 | void highlightTarget(); 11 | int loadWireObjectVoxs(); 12 | int updateExistingWireObjects(); 13 | } -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_matrix_clip_space.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | int main() 9 | { 10 | int Error = 0; 11 | 12 | return Error; 13 | } 14 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_matrix_projection.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | int main() 9 | { 10 | int Error = 0; 11 | 12 | return Error; 13 | } 14 | -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementPusher.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectBase.h" 3 | #include "Raycaster.h" 4 | 5 | namespace wireObjects { 6 | class wirePlacementPusher : public wireObj { 7 | public: 8 | RaycastFilter rcf = {}; 9 | 10 | wirePlacementPusher(); 11 | DWORD init(TDShape* housing, int memoryVal) override; 12 | DWORD exec() override; 13 | DWORD usrExec() override; 14 | }; 15 | } -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_color_space.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | int test_saturation() 5 | { 6 | int Error(0); 7 | 8 | glm::vec4 Color = glm::saturation(1.0f, glm::vec4(1.0, 0.5, 0.0, 1.0)); 9 | 10 | return Error; 11 | } 12 | 13 | int main() 14 | { 15 | int Error(0); 16 | 17 | Error += test_saturation(); 18 | 19 | return Error; 20 | } 21 | -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementRaycaster.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectBase.h" 3 | #include "Raycaster.h" 4 | 5 | namespace wireObjects { 6 | class wirePlacementRaycaster : public wireObj { 7 | public: 8 | RaycastFilter rcf = {}; 9 | 10 | wirePlacementRaycaster(); 11 | DWORD init(TDShape* housing, int memoryVal) override; 12 | DWORD exec() override; 13 | DWORD usrExec() override; 14 | }; 15 | } -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/tgtAttribute.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "tgtBase.h" 3 | #include 4 | //#include "TDObjects.h" 5 | 6 | struct tgt_attribute : public tgt { 7 | char setAttributeFirst[128] = {}; 8 | char setAttributeSecond[128] = {}; 9 | //std::vector clickedObjects = {}; 10 | bool spawnOnce = true; 11 | bool clearClickedObjects = true; 12 | 13 | tgt_attribute(); 14 | DWORD exec() override; 15 | }; -------------------------------------------------------------------------------- /diddlerInternal/tgtBalloon.cpp: -------------------------------------------------------------------------------- 1 | #include "tgtBalloon.h" 2 | #include "Global.h" 3 | #include "balloons.h" 4 | 5 | tgt_balloon::tgt_balloon() { 6 | tool = TOOL_BALLOON; 7 | } 8 | 9 | DWORD tgt_balloon::exec() { 10 | if (glb::player->isAttacking) { 11 | if (spawnOnce) { 12 | spawnOnce = false; 13 | balloons::spawnBalloon(balloonPower); 14 | } 15 | } 16 | else { 17 | spawnOnce = true; 18 | } 19 | return 0x01; 20 | } -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_texture.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | #include 4 | 5 | int test_levels() 6 | { 7 | int Error = 0; 8 | 9 | int const Levels = glm::levels(glm::ivec2(3, 2)); 10 | Error += Levels == 2 ? 0 : 1; 11 | 12 | return Error; 13 | } 14 | 15 | int main() 16 | { 17 | int Error = 0; 18 | 19 | Error += test_levels(); 20 | 21 | return Error; 22 | } 23 | -------------------------------------------------------------------------------- /diddlerInternal/balloons.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "Global.h" 4 | 5 | namespace balloons { 6 | struct balloon { 7 | TDShape* shape; 8 | TDBody* body; 9 | float upVelocity; 10 | 11 | bool destroyed = false; 12 | bool hasString = false; 13 | int wait = 1; 14 | td::Vec3 origin = { 0, 0, 0 }; 15 | }; 16 | 17 | void updateAllBalloons(); 18 | void spawnBalloon(float power); 19 | extern std::vector balloons; 20 | } -------------------------------------------------------------------------------- /diddlerInternal/Mods.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Jetpack.h" 3 | #include "godmode.h" 4 | #include "objectSpawner.h" 5 | 6 | namespace mods { 7 | extern char jetpackKey; 8 | extern char noclipKey; 9 | 10 | extern bool jetpack; 11 | extern bool flamethrower; 12 | extern bool godmode; 13 | extern bool c4_global_detonation; 14 | extern bool removeWalls; 15 | extern bool dontLockWhenOutOfFocus; 16 | extern bool isGameFocused; 17 | 18 | void execMods(); 19 | } -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_matrix_decompose.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | int main() 5 | { 6 | int Error(0); 7 | 8 | glm::mat4 Matrix(1); 9 | 10 | glm::vec3 Scale; 11 | glm::quat Orientation; 12 | glm::vec3 Translation; 13 | glm::vec3 Skew(1); 14 | glm::vec4 Perspective(1); 15 | 16 | glm::decompose(Matrix, Scale, Orientation, Translation, Skew, Perspective); 17 | 18 | return Error; 19 | } 20 | -------------------------------------------------------------------------------- /knedmod.wsp: -------------------------------------------------------------------------------- 1 | 2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio Version 16 4 | VisualStudioVersion = 16.0.31019.35 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Global 7 | GlobalSection(SolutionProperties) = preSolution 8 | HideSolutionNode = FALSE 9 | EndGlobalSection 10 | GlobalSection(ExtensibilityGlobals) = postSolution 11 | SolutionGuid = {0BA8EAAA-1122-4F5B-B33C-35393A7D0693} 12 | EndGlobalSection 13 | EndGlobal 14 | -------------------------------------------------------------------------------- /diddlerInternal/resource.h: -------------------------------------------------------------------------------- 1 | //{{NO_DEPENDENCIES}} 2 | // Microsoft Visual C++ generated include file. 3 | // Used by diddlerInternal.rc 4 | 5 | // Next default values for new objects 6 | // 7 | #ifdef APSTUDIO_INVOKED 8 | #ifndef APSTUDIO_READONLY_SYMBOLS 9 | #define _APS_NEXT_RESOURCE_VALUE 101 10 | #define _APS_NEXT_COMMAND_VALUE 40001 11 | #define _APS_NEXT_CONTROL_VALUE 1001 12 | #define _APS_NEXT_SYMED_VALUE 101 13 | #endif 14 | #endif 15 | -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementDelay.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectBase.h" 3 | 4 | namespace wireObjects { 5 | class wirePlacementDelay : public wireObj { 6 | public: 7 | bool previousInputState = false; 8 | int stateChangeCountdown = 0; 9 | int countedFrames = 0; 10 | bool counting = false; 11 | 12 | wirePlacementDelay(); 13 | DWORD init(TDShape* housing, int memoryVal) override; 14 | DWORD exec() override; 15 | DWORD usrExec() override; 16 | }; 17 | } -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_scalar_packing.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int test_packUnorm() 5 | { 6 | int Error = 0; 7 | 8 | 9 | return Error; 10 | } 11 | 12 | int test_packSnorm() 13 | { 14 | int Error = 0; 15 | 16 | 17 | return Error; 18 | } 19 | 20 | int main() 21 | { 22 | int Error = 0; 23 | 24 | Error += test_packUnorm(); 25 | Error += test_packSnorm(); 26 | 27 | return Error; 28 | } 29 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementSpawner.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectBase.h" 3 | #include "objectSpawner.h" 4 | 5 | namespace wireObjects { 6 | class wirePlacementSpawner : public wireObj { 7 | public: 8 | bool previousInputState = false; 9 | spawner::LoadedSpawnableObject object; 10 | RaycastFilter rcf = {}; 11 | 12 | wirePlacementSpawner(); 13 | DWORD init(TDShape* housing, int memoryVal) override; 14 | DWORD exec() override; 15 | DWORD usrExec() override; 16 | }; 17 | } -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/tgtIncludes.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "tgtBase.h" 3 | #include "tgtCamera.h" 4 | #include "tgtDamage.h" 5 | #include "tgtDebug.h" 6 | #include "tgtDev.h" 7 | #include "tgtExplode.h" 8 | #include "tgtLeafblower.h" 9 | #include "tgtMinigun.h" 10 | #include "tgtRemove.h" 11 | #include "tgtRope.h" 12 | #include "tgtSlice.h" 13 | #include "tgtSpawner.h" 14 | #include "tgtWeld.h" 15 | #include "tgtFlamethrower.h" 16 | #include "tgtAttribute.h" 17 | #include "tgtBalloon.h" 18 | #include "tgtWire.h" 19 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/core/core_setup_force_size_t_length.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_FORCE_SIZE_T_LENGTH 2 | #include 3 | #include 4 | 5 | template 6 | genType add(genType const& a, genType const& b) 7 | { 8 | genType result(0); 9 | for(glm::length_t i = 0; i < a.length(); ++i) 10 | result[i] = a[i] + b[i]; 11 | return result; 12 | } 13 | 14 | int main() 15 | { 16 | int Error = 0; 17 | 18 | glm::ivec4 v(1); 19 | Error += add(v, v) == glm::ivec4(2) ? 0 : 1; 20 | 21 | return Error; 22 | } 23 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/core/core_setup_platform_unknown.cpp: -------------------------------------------------------------------------------- 1 | #ifndef GLM_FORCE_PLATFORM_UNKNOWN 2 | # define GLM_FORCE_PLATFORM_UNKNOWN 3 | #endif 4 | #ifndef GLM_FORCE_COMPILER_UNKNOWN 5 | # define GLM_FORCE_COMPILER_UNKNOWN 6 | #endif 7 | #ifndef GLM_FORCE_ARCH_UNKNOWN 8 | # define GLM_FORCE_ARCH_UNKNOWN 9 | #endif 10 | #ifndef GLM_FORCE_CXX_UNKNOWN 11 | # define GLM_FORCE_CXX_UNKNOWN 12 | #endif 13 | #include 14 | #include 15 | 16 | int main() 17 | { 18 | int Error = 0; 19 | 20 | return Error; 21 | } 22 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/lantern.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "objectSpawner.h" 3 | 4 | namespace lantern { 5 | extern float a1; 6 | extern float a2; 7 | extern float a3; 8 | extern float a4; 9 | extern float a5; 10 | extern float lightR; 11 | extern float lightG; 12 | extern float lightB; 13 | 14 | void spawnLantern(); 15 | void updateLantern(); 16 | } 17 | 18 | 19 | namespace smoker { 20 | extern td::particleInfo pInfo; 21 | extern td::Vec3 velocity; 22 | extern float lifetime; 23 | 24 | void spawnSmoker(); 25 | void updateSmoker(); 26 | } -------------------------------------------------------------------------------- /diddlerInternal/console.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "windows.h" 3 | #include 4 | 5 | #define COMM_OK 0x01 6 | #define COMM_ERROR_ARGS 0x02 7 | #define COMM_ERROR_EXEC 0x03 8 | 9 | #define MSG_GENERIC 0x10 10 | #define MSG_WARNING 0x11 11 | #define MSG_ERROR 0x12 12 | #define MSG_BACKGROUND 0x13 13 | 14 | namespace console { 15 | extern bool consoleOpen; 16 | extern bool firstFocus; 17 | extern int commandReversePtr; 18 | void drawConsole(); 19 | void writeConsole(std::string text, DWORD messageType); 20 | } 21 | -------------------------------------------------------------------------------- /diddlerInternal/tgtBase.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "windows.h" 4 | 5 | enum toolnames { 6 | TOOL_SPAWNER, //done 7 | TOOL_MINIGUN, //done 8 | TOOL_CLICKEXPLODE, //done 9 | TOOL_FLAMETHROWER, 10 | TOOL_DAMAGE, 11 | TOOL_REMOVE, 12 | TOOL_ATTRIBUTE, 13 | TOOL_LEAFBLOWER, 14 | TOOL_SLICE, 15 | TOOL_CAMERA, //done 16 | TOOL_ROPE, //done 17 | TOOL_WELD, //done 18 | TOOL_DEBUG, 19 | TOOL_BALLOON, 20 | TOOL_WIRE, 21 | TOOL_DEV 22 | }; 23 | 24 | struct tgt { 25 | toolnames tool; 26 | virtual DWORD exec() = 0; 27 | }; 28 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/core/core_type_int.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | static int test_bit_operator() 5 | { 6 | int Error = 0; 7 | 8 | glm::ivec4 const a(1); 9 | glm::ivec4 const b = ~a; 10 | Error += glm::all(glm::equal(b, glm::ivec4(-2))) ? 0 : 1; 11 | 12 | glm::int32 const c(1); 13 | glm::int32 const d = ~c; 14 | Error += d == -2 ? 0 : 1; 15 | 16 | return Error; 17 | } 18 | 19 | int main() 20 | { 21 | int Error = 0; 22 | 23 | Error += test_bit_operator(); 24 | 25 | return Error; 26 | } 27 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementRadio.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectBase.h" 3 | 4 | namespace wireObjects { 5 | class wirePlacementRadioTx : public wireObj { 6 | public: 7 | wirePlacementRadioTx(); 8 | DWORD init(TDShape* housing, int memoryVal) override; 9 | DWORD exec() override; 10 | DWORD usrExec() override; 11 | }; 12 | 13 | class wirePlacementRadioRx : public wireObj { 14 | public: 15 | wirePlacementRadioRx(); 16 | DWORD init(TDShape* housing, int memoryVal) override; 17 | DWORD exec() override; 18 | DWORD usrExec() override; 19 | }; 20 | } -------------------------------------------------------------------------------- /diddlerInternal/tgtWeld.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "tgtBase.h" 4 | #include "global.h" 5 | 6 | struct tgt_weld : public tgt { 7 | bool weldStageOne = true; 8 | bool weldAttackOnce = true; 9 | float postCompletionHighlight = 1.f; 10 | 11 | TDShape* weldTargetShape1 = 0; 12 | TDBody* weldTargetBody1 = 0; 13 | TDShape* weldTargetShape2 = 0; 14 | TDBody* weldTargetBody2 = 0; 15 | td::Vec3 weldFirstPos = {}; 16 | td::Vec3 weldSecondPos = {}; 17 | TDBody* postCompletionBody = 0; 18 | 19 | tgt_weld(); 20 | DWORD exec() override; 21 | }; -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementComparisons.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectBase.h" 3 | 4 | namespace wireObjects { 5 | class wirePlacementGreaterthan : public wireObj { 6 | public: 7 | wirePlacementGreaterthan(); 8 | DWORD init(TDShape* housing, int memoryVal) override; 9 | DWORD exec() override; 10 | DWORD usrExec() override; 11 | }; 12 | 13 | class wirePlacementLessthan : public wireObj { 14 | public: 15 | wirePlacementLessthan(); 16 | DWORD init(TDShape* housing, int memoryVal) override; 17 | DWORD exec() override; 18 | DWORD usrExec() override; 19 | }; 20 | 21 | } -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/bug/bug_ms_vec_static.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_CONFIG_ANONYMOUS_STRUCT == GLM_ENABLE 4 | struct vec2; 5 | 6 | struct _swizzle 7 | { 8 | char _buffer[1]; 9 | }; 10 | 11 | struct vec2 12 | { 13 | GLM_CONSTEXPR vec2() : 14 | x(0), y(0) 15 | {} 16 | 17 | union 18 | { 19 | struct { float x, y; }; 20 | struct { _swizzle xx; }; 21 | }; 22 | }; 23 | #endif 24 | 25 | // Visual C++ has a bug generating the error: fatal error C1001: An internal error has occurred in the compiler. 26 | // vec2 Bar; 27 | 28 | int main() 29 | { 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /diddlerInternal/wireObjectSpawn.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectBase.h" 3 | #include "wirePlacements.h" 4 | #include 5 | 6 | #define W_OBJECT_COUNT 23 7 | 8 | namespace wireObjects { 9 | 10 | struct wireObjectInfo { 11 | wireObjectName name; 12 | const char* path; 13 | TDVox* voxTemplate; 14 | }; 15 | 16 | extern wireObjectInfo validWireObjects[W_OBJECT_COUNT]; 17 | 18 | wireObjectInfo findByName(wireObjectName name); 19 | 20 | //wireobjects are always spawned using the toolgun and always get placed on a target object 21 | wireObj* spawnWireObject(wireObjectName name); 22 | } -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtc/gtc_constants.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int test_epsilon() 4 | { 5 | int Error = 0; 6 | 7 | { 8 | float Test = glm::epsilon(); 9 | Error += Test > 0.0f ? 0 : 1; 10 | } 11 | 12 | { 13 | double Test = glm::epsilon(); 14 | Error += Test > 0.0 ? 0 : 1; 15 | } 16 | 17 | return Error; 18 | } 19 | 20 | int main() 21 | { 22 | int Error(0); 23 | 24 | //float MinHalf = 0.0f; 25 | //while (glm::half(MinHalf) == glm::half(0.0f)) 26 | // MinHalf += std::numeric_limits::epsilon(); 27 | Error += test_epsilon(); 28 | 29 | return Error; 30 | } 31 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_compatibility.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | int main() 5 | { 6 | int Error(0); 7 | 8 | Error += glm::isfinite(1.0f) ? 0 : 1; 9 | Error += glm::isfinite(1.0) ? 0 : 1; 10 | Error += glm::isfinite(-1.0f) ? 0 : 1; 11 | Error += glm::isfinite(-1.0) ? 0 : 1; 12 | 13 | Error += glm::all(glm::isfinite(glm::vec4(1.0f))) ? 0 : 1; 14 | Error += glm::all(glm::isfinite(glm::dvec4(1.0))) ? 0 : 1; 15 | Error += glm::all(glm::isfinite(glm::vec4(-1.0f))) ? 0 : 1; 16 | Error += glm::all(glm::isfinite(glm::dvec4(-1.0))) ? 0 : 1; 17 | 18 | return Error; 19 | } 20 | -------------------------------------------------------------------------------- /diddlerInternal/miscPatches.cpp: -------------------------------------------------------------------------------- 1 | #include "Global.h" 2 | 3 | namespace miscPatches { 4 | bool plankPatch = false; 5 | 6 | void updatePlankPatch () { 7 | byte origionalAsm[9] = {0xF3, 0x0F, 0x5F, 0xF7, 0xF3, 0x41, 0x0F, 0x5D, 0xF0}; //MAXSS XMM6, XMM7 - MINSS XMMM6, XMM8 8 | byte patchAsm[9] = {0xBA, 0xFF, 0xFF, 0xFF, 0xFF, 0x66, 0x0F, 0x6E, 0xF2}; //MOV EDX, FFFFFF - MOVD XMM6, EDX 9 | uintptr_t patchLocation = glb::plankPatchFunction + 0x466; 10 | 11 | if (plankPatch) { 12 | mem::Patch((byte*)patchLocation, patchAsm, 9); 13 | } 14 | else { 15 | mem::Patch((byte*)patchLocation, origionalAsm, 9); 16 | } 17 | } 18 | } -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/mainHook.cpp: -------------------------------------------------------------------------------- 1 | #include "TDFuncs.h" 2 | #include "types.h" 3 | #include "Global.h" 4 | 5 | void MAINHOOK(TDGame* game, void* a2) { 6 | 7 | std::cout << "game: " << std::hex << (uintptr_t)game << std::endl; 8 | 9 | return glb::oTDmain(game, a2); 10 | } 11 | 12 | 13 | void initMainHook() { 14 | DetourTransactionBegin(); 15 | DetourUpdateThread(GetCurrentThread()); 16 | DetourAttach(&(PVOID&)glb::oTDmain, MAINHOOK); 17 | DetourTransactionCommit(); 18 | } 19 | 20 | void terminateMainHook() { 21 | DetourTransactionBegin(); 22 | DetourUpdateThread(GetCurrentThread()); 23 | DetourDetach(&(PVOID&)glb::oTDmain, MAINHOOK); 24 | DetourTransactionCommit(); 25 | } -------------------------------------------------------------------------------- /diddlerInternal/snapPoints.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | //#include "TDObjects.h" 3 | #include "Global.h" 4 | #include 5 | #include 6 | #include 7 | 8 | struct snapPoint { 9 | glm::vec3 position; 10 | glm::vec3 direction; 11 | }; 12 | 13 | struct snapPointPackage { 14 | std::vector snapPoints; 15 | glm::quat parentRotation; 16 | }; 17 | 18 | namespace snapPoints { 19 | bool pointNearPoint(glm::vec3 pointA, glm::vec3 pointB, float maxDist); 20 | bool getClosestSnapPoint(glm::vec3 sourcePoint, snapPointPackage snapPackage, float maxDist, snapPoint* out); 21 | void drawSnapPoints(TDShape* shape); 22 | snapPointPackage getSnapPoints(TDShape* shape); 23 | } -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/gtc/reciprocal.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_reciprocal 2 | /// @file glm/gtc/reciprocal.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_reciprocal GLM_GTC_reciprocal 7 | /// @ingroup gtc 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Define secant, cosecant and cotangent functions. 12 | 13 | #pragma once 14 | 15 | // Dependencies 16 | #include "../detail/setup.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_GTC_reciprocal extension included") 20 | #endif 21 | 22 | #include "../ext/scalar_reciprocal.hpp" 23 | #include "../ext/vector_reciprocal.hpp" 24 | 25 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/mem.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | //https://guidedhacking.com/threads/how-to-hack-any-game-first-internal-hack-dll-tutorial.12142/ 5 | 6 | namespace mem 7 | { 8 | void Patch(BYTE* dst, BYTE* src, unsigned int size); 9 | void Nop(BYTE* dst, unsigned int size); 10 | void Null(BYTE* dst, unsigned int size); 11 | uintptr_t FindDMAAddy(uintptr_t ptr, std::vector offsets); 12 | bool Compare(const BYTE* pData, const BYTE* bMask, const char* szMask); 13 | DWORD64 FindPattern(BYTE* bMask, const char* szMask, HMODULE hModule, float* integrity = 0); 14 | bool Hook(char* src, char* dst, int len); 15 | char* TrampHook(char* src, char* dst, unsigned int len); 16 | } -------------------------------------------------------------------------------- /diddlerInternal/dotProjector.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "types.h" 3 | 4 | namespace dotProjector { 5 | struct rayPixel { 6 | td::Vec3 dirVec = { 0.f, 0.f, 0.f }; 7 | td::Vec3 worldPos = { 0.f, 0.f, 0.f }; 8 | TDShape* hitshape = 0; 9 | float dist = 0.f; 10 | int color_R = 0; 11 | int color_G = 0; 12 | int color_B = 0; 13 | bool RCSuccessful = false; 14 | }; 15 | 16 | struct pixelResponse { 17 | float minDist = 0.f; 18 | float maxDist = 0.f; 19 | size_t size; 20 | rayPixel* data; 21 | }; 22 | 23 | pixelResponse* projectDotMatrix(int resolution, float fov, float aspect, bool stochastic, glm::quat* camRotation, td::Vec3 camPosition, td::Vec3 forwardVector, td::Vec3 upVector, RaycastFilter* filter); 24 | } -------------------------------------------------------------------------------- /diddlerInternal/godmode.cpp: -------------------------------------------------------------------------------- 1 | #include "TDFuncs.h" 2 | #include "types.h" 3 | #include "Global.h" 4 | #include "Mods.h" 5 | 6 | void hkGodmode(TDPlayer* player, float damage) { 7 | if (mods::godmode) { 8 | return; 9 | } 10 | 11 | return glb::oDamagePlayer(player, damage); 12 | } 13 | 14 | void initGodmodeHook() { 15 | DetourTransactionBegin(); 16 | DetourUpdateThread(GetCurrentThread()); 17 | DetourAttach(&(PVOID&)glb::oDamagePlayer, hkGodmode); 18 | DetourTransactionCommit(); 19 | } 20 | 21 | void terminateGodmodeHook() { 22 | DetourTransactionBegin(); 23 | DetourUpdateThread(GetCurrentThread()); 24 | DetourDetach(&(PVOID&)glb::oDamagePlayer, hkGodmode); 25 | DetourTransactionCommit(); 26 | } -------------------------------------------------------------------------------- /diddlerInternal/tgtRope.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "tgtBase.h" 3 | #include "global.h" 4 | #include "types.h" 5 | #include "TDObjects.h" 6 | 7 | struct tgt_rope : public tgt { 8 | float ropeSlack = 0.f; 9 | float ropeStrength = 1.f; 10 | float ropeMaxStretch = 0.f; 11 | td::Color ropeColor = { 1.f, 1.f, 1.f, 1.f }; 12 | bool ropeAttackOnce = true; 13 | bool ropeToolFirstPos = true; 14 | td::Vec3 ropeFirstPos = {}; 15 | td::Vec3 ropeSecondPos = {}; 16 | TDShape* shape1 = 0; 17 | TDShape* shape2 = 0; 18 | td::Vec3 translatedPoint1 = {}; 19 | td::Vec3 translatedPoint2 = {}; 20 | td::Vec3 worldPos1 = {}; 21 | td::Vec3 worldPos2 = {}; 22 | 23 | tgt_rope(); 24 | DWORD exec() override; 25 | }; -------------------------------------------------------------------------------- /diddlerInternal/movementLoop.cpp: -------------------------------------------------------------------------------- 1 | #include "TDFuncs.h" 2 | #include "types.h" 3 | #include "Global.h" 4 | #include "noclip.h" 5 | #include "lantern.h" 6 | 7 | void hkMovementLoop(uintptr_t a1, float a2, uintptr_t a3, uintptr_t a4) { 8 | 9 | 10 | 11 | return glb::oCamPos(a1, a2, a3, a4); 12 | } 13 | 14 | void terminateMovementHook() { 15 | DetourTransactionBegin(); 16 | DetourUpdateThread(GetCurrentThread()); 17 | DetourDetach(&(PVOID&)glb::oCamPos, hkMovementLoop); 18 | DetourTransactionCommit(); 19 | } 20 | 21 | void initMovementHook() { 22 | DetourTransactionBegin(); 23 | DetourUpdateThread(GetCurrentThread()); 24 | DetourAttach(&(PVOID&)glb::oCamPos, hkMovementLoop); 25 | DetourTransactionCommit(); 26 | } 27 | -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementTemplate.cpp: -------------------------------------------------------------------------------- 1 | #include "wireObjectBase.h" 2 | #include "wirePlacementTemplate.h" 3 | 4 | namespace wireObjects { 5 | wirePlacementTemplate::wirePlacementTemplate() { 6 | 7 | } 8 | 9 | DWORD wirePlacementTemplate::init(TDShape* housing, int memoryVal) { 10 | this->housing = housing; 11 | this->memory = memoryVal; 12 | 13 | wireNode* _red = new wireNode(); 14 | _red->init(this, wireObjects::nodeType::NT_Bool, wireObjects::nodeColour::Red, { 0.45f, 0.15f, 0.05f }); 15 | this->nodes.push_back(_red); 16 | 17 | return 0x01; 18 | } 19 | 20 | DWORD wirePlacementTemplate::exec() { 21 | 22 | 23 | return 0x01; 24 | } 25 | 26 | DWORD wirePlacementTemplate::usrExec() { 27 | return 0x01; 28 | } 29 | 30 | } -------------------------------------------------------------------------------- /diddlerInternal/wirePlacements.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wirePlacementIntBus.h" 3 | #include "wirePlacementButton.h" 4 | #include "wirePlacementBomb.h" 5 | #include "wirePlacementBalloonDeployer.h" 6 | #include "wirePlacementBoolBus.h" 7 | #include "wirePlacementGates.h" 8 | #include "wirePlacementLamp.h" 9 | #include "wirePlacementComparisons.h" 10 | #include "wirePlacementGPS.h" 11 | #include "wirePlacementConstInt.h" 12 | #include "wirePlacementRaycaster.h" 13 | #include "wirePlacementRadio.h" 14 | #include "WirePlacementClock.h" 15 | #include "wirePlacementDelay.h" 16 | #include "wirePlacementToggle.h" 17 | #include "wirePlacementSpawner.h" 18 | #include "wirePlacementThruster.h" 19 | #include "wirePlacementPusher.h" 20 | #include "wirePlacementPower.h" -------------------------------------------------------------------------------- /diddlerInternal/tgtRemove.cpp: -------------------------------------------------------------------------------- 1 | #include "Global.h" 2 | #include "tgtRemove.h" 3 | #include "Raycaster.h" 4 | 5 | tgt_remove::tgt_remove() { 6 | 7 | } 8 | 9 | DWORD tgt_remove::exec() { 10 | 11 | raycaster::rayData rd = raycaster::castRayPlayer(); 12 | if (rd.hitShape != (TDShape*)0xCCCCCCCCCCCCCCCC) { 13 | glb::oHighlightShape(glb::renderer, rd.hitShape, 1.f); 14 | if (glb::player->isAttacking) { 15 | if (spawnOnce) { 16 | spawnOnce = false; 17 | std::cout << rd.hitShape << std::endl; 18 | rd.hitShape->Destroy(rd.hitShape, true); 19 | 20 | } 21 | } 22 | else { 23 | spawnOnce = true; 24 | } 25 | } 26 | 27 | return 0x01; 28 | } -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtc/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | glmCreateTestGTC(gtc_bitfield) 2 | glmCreateTestGTC(gtc_color_space) 3 | glmCreateTestGTC(gtc_constants) 4 | glmCreateTestGTC(gtc_epsilon) 5 | glmCreateTestGTC(gtc_integer) 6 | glmCreateTestGTC(gtc_matrix_access) 7 | glmCreateTestGTC(gtc_matrix_integer) 8 | glmCreateTestGTC(gtc_matrix_inverse) 9 | glmCreateTestGTC(gtc_matrix_transform) 10 | glmCreateTestGTC(gtc_noise) 11 | glmCreateTestGTC(gtc_packing) 12 | glmCreateTestGTC(gtc_quaternion) 13 | glmCreateTestGTC(gtc_random) 14 | glmCreateTestGTC(gtc_round) 15 | glmCreateTestGTC(gtc_reciprocal) 16 | glmCreateTestGTC(gtc_type_aligned) 17 | glmCreateTestGTC(gtc_type_precision) 18 | glmCreateTestGTC(gtc_type_ptr) 19 | glmCreateTestGTC(gtc_ulp) 20 | glmCreateTestGTC(gtc_vec1) 21 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_gradient_paint.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | 4 | int test_radialGradient() 5 | { 6 | int Error = 0; 7 | 8 | float Gradient = glm::radialGradient(glm::vec2(0), 1.0f, glm::vec2(1), glm::vec2(0.5)); 9 | Error += Gradient != 0.0f ? 0 : 1; 10 | 11 | return Error; 12 | } 13 | 14 | int test_linearGradient() 15 | { 16 | int Error = 0; 17 | 18 | float Gradient = glm::linearGradient(glm::vec2(0), glm::vec2(1), glm::vec2(0.5)); 19 | Error += Gradient != 0.0f ? 0 : 1; 20 | 21 | return Error; 22 | } 23 | 24 | int main() 25 | { 26 | int Error = 0; 27 | 28 | Error += test_radialGradient(); 29 | Error += test_linearGradient(); 30 | 31 | return Error; 32 | } 33 | 34 | 35 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_int_10_10_10_2.cpp: -------------------------------------------------------------------------------- 1 | /////////////////////////////////////////////////////////////////////////////////////////////////// 2 | // OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) 3 | /////////////////////////////////////////////////////////////////////////////////////////////////// 4 | // Created : 2013-10-25 5 | // Updated : 2013-10-25 6 | // Licence : This source is under MIT licence 7 | // File : test/gtx/associated_min_max.cpp 8 | /////////////////////////////////////////////////////////////////////////////////////////////////// 9 | 10 | #include 11 | #include 12 | 13 | int main() 14 | { 15 | int Error(0); 16 | 17 | return Error; 18 | } 19 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_mixed_product.cpp: -------------------------------------------------------------------------------- 1 | /////////////////////////////////////////////////////////////////////////////////////////////////// 2 | // OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) 3 | /////////////////////////////////////////////////////////////////////////////////////////////////// 4 | // Created : 2013-10-25 5 | // Updated : 2013-10-25 6 | // Licence : This source is under MIT licence 7 | // File : test/gtx/associated_min_max.cpp 8 | /////////////////////////////////////////////////////////////////////////////////////////////////// 9 | 10 | #include 11 | #include 12 | 13 | int main() 14 | { 15 | int Error(0); 16 | 17 | return Error; 18 | } 19 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementConstInt.cpp: -------------------------------------------------------------------------------- 1 | #include "wireObjectBase.h" 2 | #include "wirePlacementConstInt.h" 3 | 4 | namespace wireObjects { 5 | 6 | wirePlacementConstInt::wirePlacementConstInt() { 7 | 8 | } 9 | 10 | DWORD wirePlacementConstInt::init(TDShape* housing, int memoryVal) { 11 | this->housing = housing; 12 | this->memory = memoryVal; 13 | 14 | wireNode* _red = new wireNode(); 15 | _red->init(this, wireObjects::nodeType::NT_Numeric, wireObjects::nodeColour::Red, { 0.25f, 0.15f, 0.05f }); 16 | this->nodes.push_back(_red); 17 | 18 | return 0x01; 19 | } 20 | 21 | DWORD wirePlacementConstInt::exec() { 22 | nodes[0]->setValue(memory); 23 | return 0x01; 24 | } 25 | 26 | DWORD wirePlacementConstInt::usrExec() { 27 | return 0x01; 28 | } 29 | 30 | } -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementGates.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "wireObjectBase.h" 3 | 4 | namespace wireObjects { 5 | class wirePlacementAND : public wireObj { 6 | public: 7 | wirePlacementAND(); 8 | DWORD init(TDShape* housing, int memoryVal) override; 9 | DWORD exec() override; 10 | DWORD usrExec() override; 11 | }; 12 | 13 | class wirePlacementOR : public wireObj { 14 | public: 15 | wirePlacementOR(); 16 | DWORD init(TDShape* housing, int memoryVal) override; 17 | DWORD exec() override; 18 | DWORD usrExec() override; 19 | }; 20 | 21 | 22 | class wirePlacementNOT : public wireObj { 23 | public: 24 | wirePlacementNOT(); 25 | DWORD init(TDShape* housing, int memoryVal) override; 26 | DWORD exec() override; 27 | DWORD usrExec() override; 28 | }; 29 | } -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_scalar_constants.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | template 4 | static int test_epsilon() 5 | { 6 | int Error = 0; 7 | 8 | valType const Test = glm::epsilon(); 9 | Error += Test > static_cast(0) ? 0 : 1; 10 | 11 | return Error; 12 | } 13 | 14 | template 15 | static int test_pi() 16 | { 17 | int Error = 0; 18 | 19 | valType const Test = glm::pi(); 20 | Error += Test > static_cast(3.14) ? 0 : 1; 21 | Error += Test < static_cast(3.15) ? 0 : 1; 22 | 23 | return Error; 24 | } 25 | 26 | int main() 27 | { 28 | int Error = 0; 29 | 30 | Error += test_epsilon(); 31 | Error += test_epsilon(); 32 | Error += test_pi(); 33 | Error += test_pi(); 34 | 35 | return Error; 36 | } 37 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_functions.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int test_gauss_1d() 6 | { 7 | int Error = 0; 8 | 9 | std::vector Result(20); 10 | for(std::size_t i = 0, n = Result.size(); i < n; ++i) 11 | Result[i] = glm::gauss(static_cast(i) * 0.1f, 0.0f, 1.0f); 12 | 13 | return Error; 14 | } 15 | 16 | int test_gauss_2d() 17 | { 18 | int Error = 0; 19 | 20 | std::vector Result(20); 21 | for(std::size_t i = 0, n = Result.size(); i < n; ++i) 22 | Result[i] = glm::gauss(glm::vec2(static_cast(i)) * 0.1f, glm::vec2(0.0f), glm::vec2(1.0f)); 23 | 24 | return Error; 25 | } 26 | 27 | int main() 28 | { 29 | int Error = 0; 30 | 31 | Error += test_gauss_1d(); 32 | Error += test_gauss_2d(); 33 | 34 | return Error; 35 | } 36 | 37 | -------------------------------------------------------------------------------- /diddlerInternal/detver.h: -------------------------------------------------------------------------------- 1 | ////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // Common version parameters. 4 | // 5 | // Microsoft Research Detours Package, Version 4.0.1 6 | // 7 | // Copyright (c) Microsoft Corporation. All rights reserved. 8 | // 9 | 10 | #define _USING_V110_SDK71_ 1 11 | #include "winver.h" 12 | #if 0 13 | #include 14 | #include 15 | #else 16 | #ifndef DETOURS_STRINGIFY 17 | #define DETOURS_STRINGIFY(x) DETOURS_STRINGIFY_(x) 18 | #define DETOURS_STRINGIFY_(x) #x 19 | #endif 20 | 21 | #define VER_FILEFLAGSMASK 0x3fL 22 | #define VER_FILEFLAGS 0x0L 23 | #define VER_FILEOS 0x00040004L 24 | #define VER_FILETYPE 0x00000002L 25 | #define VER_FILESUBTYPE 0x00000000L 26 | #endif 27 | #define VER_DETOURS_BITS DETOUR_STRINGIFY(DETOURS_BITS) 28 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # KnedMod - a (defunct) sandbox oriented mod for teardown 2 | 3 | The main purpose of KnedMod is to give you a spawn menu within teardown that can be used to dynamically add new objects to the world. 4 | It also adds a toolgun with various functions and a noclip mode. 5 | This is considered far from a complete project and has a lot of known bugs that can cause crashes, however i feel it is a good resource for anyone attempting to make their own mod. 6 | 7 | Building requires MS Detours and GLEW. KnedMod is released under the GNU GPL v3 license. 8 | 9 | COMPILED BINARIES AND INSTALL INSTRUCTIONS ARE AVAILABLE ON THIS SERVER: https://discord.gg/d4uW3hG 10 | LOOK UNDER #mod_submissions AND FOLLOW THE README 11 | 12 | Tons of thanks to [SK83RJOSH](https://github.com/SK83RJOSH), [Nahu](https://github.com/nxhu64) and [Xorberax](https://github.com/ss-gnalvesteffer) 13 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/cmake/test_find_glm.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | glm::mat4 camera(float Translate, glm::vec2 const& Rotate) 6 | { 7 | glm::mat4 Projection = glm::perspective(glm::pi() * 0.25f, 4.0f / 3.0f, 0.1f, 100.f); 8 | glm::mat4 View = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Translate)); 9 | View = glm::rotate(View, Rotate.y, glm::vec3(-1.0f, 0.0f, 0.0f)); 10 | View = glm::rotate(View, Rotate.x, glm::vec3(0.0f, 1.0f, 0.0f)); 11 | glm::mat4 Model = glm::scale(glm::mat4(1.0f), glm::vec3(0.5f)); 12 | return Projection * View * Model; 13 | } 14 | 15 | int main() 16 | { 17 | const glm::mat4 m = camera(1.f, glm::vec2(1.f, 0.5f)); 18 | std::cout << "matrix diagonal: " << m[0][0] << ", " 19 | << m[1][1] << ", " << m[2][2] << ", " << m[3][3] << "\n"; 20 | return 0; 21 | } 22 | 23 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_matrix_int2x3_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::i8mat2x3) == 6, "int8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::i16mat2x3) == 12, "int16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::i32mat2x3) == 24, "int32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::i64mat2x3) == 48, "int64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_comp() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::i8mat2x3) < sizeof(glm::i16mat2x3) ? 0 : 1; 15 | Error += sizeof(glm::i16mat2x3) < sizeof(glm::i32mat2x3) ? 0 : 1; 16 | Error += sizeof(glm::i32mat2x3) < sizeof(glm::i64mat2x3) ? 0 : 1; 17 | 18 | return Error; 19 | } 20 | 21 | int main() 22 | { 23 | int Error = 0; 24 | 25 | Error += test_comp(); 26 | 27 | return Error; 28 | } 29 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_matrix_int2x4_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::i8mat2x4) == 8, "int8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::i16mat2x4) == 16, "int16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::i32mat2x4) == 32, "int32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::i64mat2x4) == 64, "int64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_comp() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::i8mat2x4) < sizeof(glm::i16mat2x4) ? 0 : 1; 15 | Error += sizeof(glm::i16mat2x4) < sizeof(glm::i32mat2x4) ? 0 : 1; 16 | Error += sizeof(glm::i32mat2x4) < sizeof(glm::i64mat2x4) ? 0 : 1; 17 | 18 | return Error; 19 | } 20 | 21 | int main() 22 | { 23 | int Error = 0; 24 | 25 | Error += test_comp(); 26 | 27 | return Error; 28 | } 29 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_matrix_int3x2_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::i8mat3x2) == 6, "int8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::i16mat3x2) == 12, "int16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::i32mat3x2) == 24, "int32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::i64mat3x2) == 48, "int64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_comp() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::i8mat3x2) < sizeof(glm::i16mat3x2) ? 0 : 1; 15 | Error += sizeof(glm::i16mat3x2) < sizeof(glm::i32mat3x2) ? 0 : 1; 16 | Error += sizeof(glm::i32mat3x2) < sizeof(glm::i64mat3x2) ? 0 : 1; 17 | 18 | return Error; 19 | } 20 | 21 | int main() 22 | { 23 | int Error = 0; 24 | 25 | Error += test_comp(); 26 | 27 | return Error; 28 | } 29 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_matrix_int3x3_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::i8mat3x3) == 9, "int8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::i16mat3x3) == 18, "int16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::i32mat3x3) == 36, "int32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::i64mat3x3) == 72, "int64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_comp() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::i8mat3x3) < sizeof(glm::i16mat3x3) ? 0 : 1; 15 | Error += sizeof(glm::i16mat3x3) < sizeof(glm::i32mat3x3) ? 0 : 1; 16 | Error += sizeof(glm::i32mat3x3) < sizeof(glm::i64mat3x3) ? 0 : 1; 17 | 18 | return Error; 19 | } 20 | 21 | int main() 22 | { 23 | int Error = 0; 24 | 25 | Error += test_comp(); 26 | 27 | return Error; 28 | } 29 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_matrix_int4x2_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::i8mat4x2) == 8, "int8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::i16mat4x2) == 16, "int16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::i32mat4x2) == 32, "int32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::i64mat4x2) == 64, "int64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_comp() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::i8mat4x2) < sizeof(glm::i16mat4x2) ? 0 : 1; 15 | Error += sizeof(glm::i16mat4x2) < sizeof(glm::i32mat4x2) ? 0 : 1; 16 | Error += sizeof(glm::i32mat4x2) < sizeof(glm::i64mat4x2) ? 0 : 1; 17 | 18 | return Error; 19 | } 20 | 21 | int main() 22 | { 23 | int Error = 0; 24 | 25 | Error += test_comp(); 26 | 27 | return Error; 28 | } 29 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtc/gtc_user_defined_types.cpp: -------------------------------------------------------------------------------- 1 | /////////////////////////////////////////////////////////////////////////////////////////////////// 2 | // OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net) 3 | /////////////////////////////////////////////////////////////////////////////////////////////////// 4 | // Created : 2010-09-16 5 | // Updated : 2011-05-27 6 | // Licence : This source is under MIT licence 7 | // File : test/gtc/type_ptr.cpp 8 | /////////////////////////////////////////////////////////////////////////////////////////////////// 9 | 10 | #define GLM_FORCE_RADIANS 11 | #include 12 | 13 | int test_make_pointer_vec() 14 | { 15 | int Error = 0; 16 | 17 | glm::func(); 18 | //func(); 19 | 20 | return Error; 21 | } 22 | 23 | int main() 24 | { 25 | int Error = 0; 26 | 27 | Error += test_make_pointer_vec(); 28 | 29 | return Error; 30 | } 31 | -------------------------------------------------------------------------------- /diddlerInternal/focusHook.cpp: -------------------------------------------------------------------------------- 1 | #include "TDFuncs.h" 2 | #include "types.h" 3 | #include "Global.h" 4 | #include 5 | #include "Mods.h" 6 | 7 | namespace focusHook { 8 | 9 | bool hkGetFocus(void* a1){ 10 | mods::isGameFocused = glb::oIsActive(a1); 11 | 12 | if (mods::dontLockWhenOutOfFocus) { 13 | return true; 14 | } 15 | else { 16 | return mods::isGameFocused; 17 | } 18 | } 19 | 20 | void initFocusHook() { 21 | DetourTransactionBegin(); 22 | DetourUpdateThread(GetCurrentThread()); 23 | DetourAttach(&(PVOID&)glb::oIsActive, hkGetFocus); 24 | DetourTransactionCommit(); 25 | } 26 | 27 | void terminateFocusHook() { 28 | DetourTransactionBegin(); 29 | DetourUpdateThread(GetCurrentThread()); 30 | DetourDetach(&(PVOID&)glb::oIsActive, hkGetFocus); 31 | DetourTransactionCommit(); 32 | } 33 | } -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_matrix_int2x2_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::i8mat2x2) == 4, "int8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::i16mat2x2) == 8, "int16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::i32mat2x2) == 16, "int32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::i64mat2x2) == 32, "int64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_comp() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::i8mat2x2) < sizeof(glm::i16mat2x2) ? 0 : 1; 15 | Error += sizeof(glm::i16mat2x2) < sizeof(glm::i32mat2x2) ? 0 : 1; 16 | Error += sizeof(glm::i32mat2x2) < sizeof(glm::i64mat2x2) ? 0 : 1; 17 | 18 | return Error; 19 | } 20 | 21 | int main() 22 | { 23 | int Error = 0; 24 | 25 | Error += test_comp(); 26 | 27 | return Error; 28 | } 29 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_matrix_int3x4_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::i8mat3x4) == 12, "int8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::i16mat3x4) == 24, "int16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::i32mat3x4) == 48, "int32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::i64mat3x4) == 96, "int64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_comp() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::i8mat3x4) < sizeof(glm::i16mat3x4) ? 0 : 1; 15 | Error += sizeof(glm::i16mat3x4) < sizeof(glm::i32mat3x4) ? 0 : 1; 16 | Error += sizeof(glm::i32mat3x4) < sizeof(glm::i64mat3x4) ? 0 : 1; 17 | 18 | return Error; 19 | } 20 | 21 | int main() 22 | { 23 | int Error = 0; 24 | 25 | Error += test_comp(); 26 | 27 | return Error; 28 | } 29 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_matrix_int4x3_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::i8mat4x3) == 12, "int8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::i16mat4x3) == 24, "int16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::i32mat4x3) == 48, "int32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::i64mat4x3) == 96, "int64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_comp() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::i8mat4x3) < sizeof(glm::i16mat4x3) ? 0 : 1; 15 | Error += sizeof(glm::i16mat4x3) < sizeof(glm::i32mat4x3) ? 0 : 1; 16 | Error += sizeof(glm::i32mat4x3) < sizeof(glm::i64mat4x3) ? 0 : 1; 17 | 18 | return Error; 19 | } 20 | 21 | int main() 22 | { 23 | int Error = 0; 24 | 25 | Error += test_comp(); 26 | 27 | return Error; 28 | } 29 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_matrix_int4x4_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::i8mat4x4) == 16, "int8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::i16mat4x4) == 32, "int16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::i32mat4x4) == 64, "int32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::i64mat4x4) == 128, "int64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_comp() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::i8mat4x4) < sizeof(glm::i16mat4x4) ? 0 : 1; 15 | Error += sizeof(glm::i16mat4x4) < sizeof(glm::i32mat4x4) ? 0 : 1; 16 | Error += sizeof(glm::i32mat4x4) < sizeof(glm::i64mat4x4) ? 0 : 1; 17 | 18 | return Error; 19 | } 20 | 21 | int main() 22 | { 23 | int Error = 0; 24 | 25 | Error += test_comp(); 26 | 27 | return Error; 28 | } 29 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_matrix_uint2x2_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::u8mat2x2) == 4, "uint8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::u16mat2x2) == 8, "uint16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::u32mat2x2) == 16, "uint32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::u64mat2x2) == 32, "uint64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_comp() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::u8mat2x2) < sizeof(glm::u16mat2x2) ? 0 : 1; 15 | Error += sizeof(glm::u16mat2x2) < sizeof(glm::u32mat2x2) ? 0 : 1; 16 | Error += sizeof(glm::u32mat2x2) < sizeof(glm::u64mat2x2) ? 0 : 1; 17 | 18 | return Error; 19 | } 20 | 21 | int main() 22 | { 23 | int Error = 0; 24 | 25 | Error += test_comp(); 26 | 27 | return Error; 28 | } 29 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_matrix_uint2x3_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::u8mat2x3) == 6, "uint8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::u16mat2x3) == 12, "uint16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::u32mat2x3) == 24, "uint32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::u64mat2x3) == 48, "uint64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_comp() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::u8mat2x3) < sizeof(glm::u16mat2x3) ? 0 : 1; 15 | Error += sizeof(glm::u16mat2x3) < sizeof(glm::u32mat2x3) ? 0 : 1; 16 | Error += sizeof(glm::u32mat2x3) < sizeof(glm::u64mat2x3) ? 0 : 1; 17 | 18 | return Error; 19 | } 20 | 21 | int main() 22 | { 23 | int Error = 0; 24 | 25 | Error += test_comp(); 26 | 27 | return Error; 28 | } 29 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_matrix_uint2x4_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::u8mat2x4) == 8, "uint8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::u16mat2x4) == 16, "uint16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::u32mat2x4) == 32, "uint32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::u64mat2x4) == 64, "uint64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_comp() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::u8mat2x4) < sizeof(glm::u16mat2x4) ? 0 : 1; 15 | Error += sizeof(glm::u16mat2x4) < sizeof(glm::u32mat2x4) ? 0 : 1; 16 | Error += sizeof(glm::u32mat2x4) < sizeof(glm::u64mat2x4) ? 0 : 1; 17 | 18 | return Error; 19 | } 20 | 21 | int main() 22 | { 23 | int Error = 0; 24 | 25 | Error += test_comp(); 26 | 27 | return Error; 28 | } 29 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_matrix_uint3x2_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::u8mat3x2) == 6, "uint8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::u16mat3x2) == 12, "uint16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::u32mat3x2) == 24, "uint32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::u64mat3x2) == 48, "uint64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_comp() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::u8mat3x2) < sizeof(glm::u16mat3x2) ? 0 : 1; 15 | Error += sizeof(glm::u16mat3x2) < sizeof(glm::u32mat3x2) ? 0 : 1; 16 | Error += sizeof(glm::u32mat3x2) < sizeof(glm::u64mat3x2) ? 0 : 1; 17 | 18 | return Error; 19 | } 20 | 21 | int main() 22 | { 23 | int Error = 0; 24 | 25 | Error += test_comp(); 26 | 27 | return Error; 28 | } 29 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_matrix_uint3x3_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::u8mat3x3) == 9, "uint8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::u16mat3x3) == 18, "uint16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::u32mat3x3) == 36, "uint32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::u64mat3x3) == 72, "uint64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_comp() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::u8mat3x3) < sizeof(glm::u16mat3x3) ? 0 : 1; 15 | Error += sizeof(glm::u16mat3x3) < sizeof(glm::u32mat3x3) ? 0 : 1; 16 | Error += sizeof(glm::u32mat3x3) < sizeof(glm::u64mat3x3) ? 0 : 1; 17 | 18 | return Error; 19 | } 20 | 21 | int main() 22 | { 23 | int Error = 0; 24 | 25 | Error += test_comp(); 26 | 27 | return Error; 28 | } 29 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_matrix_uint3x4_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::u8mat3x4) == 12, "uint8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::u16mat3x4) == 24, "uint16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::u32mat3x4) == 48, "uint32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::u64mat3x4) == 96, "uint64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_comp() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::u8mat3x4) < sizeof(glm::u16mat3x4) ? 0 : 1; 15 | Error += sizeof(glm::u16mat3x4) < sizeof(glm::u32mat3x4) ? 0 : 1; 16 | Error += sizeof(glm::u32mat3x4) < sizeof(glm::u64mat3x4) ? 0 : 1; 17 | 18 | return Error; 19 | } 20 | 21 | int main() 22 | { 23 | int Error = 0; 24 | 25 | Error += test_comp(); 26 | 27 | return Error; 28 | } 29 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_matrix_uint4x2_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::u8mat4x2) == 8, "uint8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::u16mat4x2) == 16, "uint16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::u32mat4x2) == 32, "uint32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::u64mat4x2) == 64, "uint64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_comp() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::u8mat4x2) < sizeof(glm::u16mat4x2) ? 0 : 1; 15 | Error += sizeof(glm::u16mat4x2) < sizeof(glm::u32mat4x2) ? 0 : 1; 16 | Error += sizeof(glm::u32mat4x2) < sizeof(glm::u64mat4x2) ? 0 : 1; 17 | 18 | return Error; 19 | } 20 | 21 | int main() 22 | { 23 | int Error = 0; 24 | 25 | Error += test_comp(); 26 | 27 | return Error; 28 | } 29 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_matrix_uint4x3_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::u8mat4x3) == 12, "uint8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::u16mat4x3) == 24, "uint16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::u32mat4x3) == 48, "uint32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::u64mat4x3) == 96, "uint64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_comp() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::u8mat4x3) < sizeof(glm::u16mat4x3) ? 0 : 1; 15 | Error += sizeof(glm::u16mat4x3) < sizeof(glm::u32mat4x3) ? 0 : 1; 16 | Error += sizeof(glm::u32mat4x3) < sizeof(glm::u64mat4x3) ? 0 : 1; 17 | 18 | return Error; 19 | } 20 | 21 | int main() 22 | { 23 | int Error = 0; 24 | 25 | Error += test_comp(); 26 | 27 | return Error; 28 | } 29 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_matrix_uint4x4_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::u8mat4x4) == 16, "uint8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::u16mat4x4) == 32, "uint16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::u32mat4x4) == 64, "uint32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::u64mat4x4) == 128, "uint64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_comp() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::u8mat4x4) < sizeof(glm::u16mat4x4) ? 0 : 1; 15 | Error += sizeof(glm::u16mat4x4) < sizeof(glm::u32mat4x4) ? 0 : 1; 16 | Error += sizeof(glm::u32mat4x4) < sizeof(glm::u64mat4x4) ? 0 : 1; 17 | 18 | return Error; 19 | } 20 | 21 | int main() 22 | { 23 | int Error = 0; 24 | 25 | Error += test_comp(); 26 | 27 | return Error; 28 | } 29 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/Raycaster.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "types.h" 3 | #include "Global.h" 4 | 5 | namespace raycaster { 6 | 7 | struct VoxelMaterial 8 | { 9 | float m_Reflectivity; 10 | float m_Roughness; 11 | float m_Metallic; 12 | float m_Emission; 13 | }; 14 | 15 | struct VoxelColor 16 | { 17 | float m_R; 18 | float m_G; 19 | float m_B; 20 | float m_A; 21 | }; 22 | 23 | struct VoxelPaletteInfo 24 | { 25 | uint32_t m_Type; 26 | VoxelColor m_Color; 27 | VoxelMaterial m_Material; 28 | uint32_t m_Pad20; 29 | }; 30 | 31 | struct palInfo { 32 | byte data[128] = {}; 33 | }; 34 | 35 | struct rayData { 36 | bool successful = false; 37 | float distance; 38 | td::Vec3 worldPos; 39 | td::Vec3 angle; 40 | TDShape* hitShape; 41 | VoxelPaletteInfo palette = {}; 42 | }; 43 | 44 | rayData castRayManual(td::Vec3 position, td::Vec3 rotation, RaycastFilter* filterCus); 45 | rayData castRayPlayer(); 46 | 47 | } 48 | 49 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/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 | -------------------------------------------------------------------------------- /diddlerInternal/glm/cmake/cmake_uninstall.cmake.in: -------------------------------------------------------------------------------- 1 | if(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt") 2 | message(FATAL_ERROR "Cannot find install manifest: @CMAKE_BINARY_DIR@/install_manifest.txt") 3 | endif() 4 | 5 | file(READ "@CMAKE_BINARY_DIR@/install_manifest.txt" files) 6 | string(REGEX REPLACE "\n" ";" files "${files}") 7 | foreach(file ${files}) 8 | message(STATUS "Uninstalling $ENV{DESTDIR}${file}") 9 | if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") 10 | exec_program( 11 | "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\"" 12 | OUTPUT_VARIABLE rm_out 13 | RETURN_VALUE rm_retval 14 | ) 15 | if(NOT "${rm_retval}" STREQUAL 0) 16 | message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}") 17 | endif() 18 | else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") 19 | message(STATUS "File $ENV{DESTDIR}${file} does not exist.") 20 | endif() 21 | endforeach() 22 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/ext/matrix_int2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int2x2 2 | /// @file glm/ext/matrix_int2x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x2 GLM_EXT_matrix_int2x2 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 "../mat2x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int2x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int2x2 25 | /// @{ 26 | 27 | /// Signed integer 2x2 matrix. 28 | /// 29 | /// @see ext_matrix_int2x2 30 | typedef mat<2, 2, int, defaultp> imat2x2; 31 | 32 | /// Signed integer 2x2 matrix. 33 | /// 34 | /// @see ext_matrix_int2x2 35 | typedef mat<2, 2, int, defaultp> imat2; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/ext/matrix_int3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int3x3 2 | /// @file glm/ext/matrix_int3x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x3 GLM_EXT_matrix_int3x3 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 "../mat3x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int3x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int3x3 25 | /// @{ 26 | 27 | /// Signed integer 3x3 matrix. 28 | /// 29 | /// @see ext_matrix_int3x3 30 | typedef mat<3, 3, int, defaultp> imat3x3; 31 | 32 | /// Signed integer 3x3 matrix. 33 | /// 34 | /// @see ext_matrix_int3x3 35 | typedef mat<3, 3, int, defaultp> imat3; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/ext/matrix_int4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int4x4 2 | /// @file glm/ext/matrix_int4x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int4x4 GLM_EXT_matrix_int4x4 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 "../mat4x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_int4x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_int4x4 25 | /// @{ 26 | 27 | /// Signed integer 4x4 matrix. 28 | /// 29 | /// @see ext_matrix_int4x4 30 | typedef mat<4, 4, int, defaultp> imat4x4; 31 | 32 | /// Signed integer 4x4 matrix. 33 | /// 34 | /// @see ext_matrix_int4x4 35 | typedef mat<4, 4, int, defaultp> imat4; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/ext/matrix_uint2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint2x2 2 | /// @file glm/ext/matrix_uint2x2.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint2x2 GLM_EXT_matrix_uint2x2 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 "../mat2x2.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint2x2 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint2x2 25 | /// @{ 26 | 27 | /// Unsigned integer 2x2 matrix. 28 | /// 29 | /// @see ext_matrix_uint2x2 30 | typedef mat<2, 2, uint, defaultp> umat2x2; 31 | 32 | /// Unsigned integer 2x2 matrix. 33 | /// 34 | /// @see ext_matrix_uint2x2 35 | typedef mat<2, 2, uint, defaultp> umat2; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/ext/matrix_uint3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint3x3 2 | /// @file glm/ext/matrix_uint3x3.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint3x3 GLM_EXT_matrix_uint3x3 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 "../mat3x3.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint3x3 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint3x3 25 | /// @{ 26 | 27 | /// Unsigned integer 3x3 matrix. 28 | /// 29 | /// @see ext_matrix_uint3x3 30 | typedef mat<3, 3, uint, defaultp> umat3x3; 31 | 32 | /// Unsigned integer 3x3 matrix. 33 | /// 34 | /// @see ext_matrix_uint3x3 35 | typedef mat<3, 3, uint, defaultp> umat3; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/ext/matrix_uint4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint4x4 2 | /// @file glm/ext/matrix_uint4x4.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint4x4 GLM_EXT_matrix_uint4x4 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 "../mat4x4.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_uint4x4 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_uint4x4 25 | /// @{ 26 | 27 | /// Unsigned integer 4x4 matrix. 28 | /// 29 | /// @see ext_matrix_uint4x4 30 | typedef mat<4, 4, uint, defaultp> umat4x4; 31 | 32 | /// Unsigned integer 4x4 matrix. 33 | /// 34 | /// @see ext_matrix_uint4x4 35 | typedef mat<4, 4, uint, defaultp> umat4; 36 | 37 | /// @} 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/detail/func_exponential_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/func_exponential_simd.inl 3 | 4 | #include "../simd/exponential.h" 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | namespace glm{ 9 | namespace detail 10 | { 11 | template 12 | struct compute_sqrt<4, float, Q, true> 13 | { 14 | GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v) 15 | { 16 | vec<4, float, Q> Result; 17 | Result.data = _mm_sqrt_ps(v.data); 18 | return Result; 19 | } 20 | }; 21 | 22 | # if GLM_CONFIG_ALIGNED_GENTYPES == GLM_ENABLE 23 | template<> 24 | struct compute_sqrt<4, float, aligned_lowp, true> 25 | { 26 | GLM_FUNC_QUALIFIER static vec<4, float, aligned_lowp> call(vec<4, float, aligned_lowp> const& v) 27 | { 28 | vec<4, float, aligned_lowp> Result; 29 | Result.data = glm_vec4_sqrt_lowp(v.data); 30 | return Result; 31 | } 32 | }; 33 | # endif 34 | }//namespace detail 35 | }//namespace glm 36 | 37 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 38 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/gtx/wrap.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_wrap 2 | /// @file glm/gtx/wrap.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_wrap GLM_GTX_wrap 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Wrapping mode of texture coordinates. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | #include "../ext/scalar_common.hpp" 18 | #include "../ext/vector_common.hpp" 19 | #include "../gtc/vec1.hpp" 20 | 21 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 22 | # ifndef GLM_ENABLE_EXPERIMENTAL 23 | # pragma message("GLM: GLM_GTX_wrap is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 24 | # else 25 | # pragma message("GLM: GLM_GTX_wrap extension included") 26 | # endif 27 | #endif 28 | 29 | namespace glm 30 | { 31 | /// @addtogroup gtx_wrap 32 | /// @{ 33 | 34 | /// @} 35 | }// namespace glm 36 | 37 | #include "wrap.inl" 38 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/ext/vector_bool1_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_bool1_precision 2 | /// @file glm/ext/vector_bool1_precision.hpp 3 | /// 4 | /// @defgroup ext_vector_bool1_precision GLM_EXT_vector_bool1_precision 5 | /// @ingroup ext 6 | /// 7 | /// Exposes highp_bvec1, mediump_bvec1 and lowp_bvec1 types. 8 | /// 9 | /// Include to use the features of this extension. 10 | 11 | #pragma once 12 | 13 | #include "../detail/type_vec1.hpp" 14 | 15 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 16 | # pragma message("GLM: GLM_EXT_vector_bool1_precision extension included") 17 | #endif 18 | 19 | namespace glm 20 | { 21 | /// @addtogroup ext_vector_bool1_precision 22 | /// @{ 23 | 24 | /// 1 component vector of bool values. 25 | typedef vec<1, bool, highp> highp_bvec1; 26 | 27 | /// 1 component vector of bool values. 28 | typedef vec<1, bool, mediump> mediump_bvec1; 29 | 30 | /// 1 component vector of bool values. 31 | typedef vec<1, bool, lowp> lowp_bvec1; 32 | 33 | /// @} 34 | }//namespace glm 35 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/gtx/scalar_relational.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_scalar_relational 2 | /// @file glm/gtx/scalar_relational.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_scalar_relational GLM_GTX_scalar_relational 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Extend a position from a source to a position at a defined length. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # ifndef GLM_ENABLE_EXPERIMENTAL 20 | # pragma message("GLM: GLM_GTX_extend is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 21 | # else 22 | # pragma message("GLM: GLM_GTX_extend extension included") 23 | # endif 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_scalar_relational 29 | /// @{ 30 | 31 | 32 | 33 | /// @} 34 | }//namespace glm 35 | 36 | #include "scalar_relational.inl" 37 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_quaternion_trigonometric.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | float const Epsilon = 0.001f; 7 | 8 | static int test_angle() 9 | { 10 | int Error = 0; 11 | 12 | { 13 | glm::quat const Q = glm::quat(glm::vec3(1, 0, 0), glm::vec3(0, 1, 0)); 14 | float const A = glm::degrees(glm::angle(Q)); 15 | Error += glm::equal(A, 90.0f, Epsilon) ? 0 : 1; 16 | } 17 | 18 | { 19 | glm::quat const Q = glm::quat(glm::vec3(0, 1, 0), glm::vec3(1, 0, 0)); 20 | float const A = glm::degrees(glm::angle(Q)); 21 | Error += glm::equal(A, 90.0f, Epsilon) ? 0 : 1; 22 | } 23 | 24 | { 25 | glm::quat const Q = glm::angleAxis(glm::two_pi() - 1.0f, glm::vec3(1, 0, 0)); 26 | float const A = glm::angle(Q); 27 | Error += glm::equal(A, 1.0f, Epsilon) ? 1 : 0; 28 | } 29 | 30 | return Error; 31 | } 32 | 33 | int main() 34 | { 35 | int Error = 0; 36 | 37 | Error += test_angle(); 38 | 39 | return Error; 40 | } 41 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/gtx/gradient_paint.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_gradient_paint 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER T radialGradient 7 | ( 8 | vec<2, T, Q> const& Center, 9 | T const& Radius, 10 | vec<2, T, Q> const& Focal, 11 | vec<2, T, Q> const& Position 12 | ) 13 | { 14 | vec<2, T, Q> F = Focal - Center; 15 | vec<2, T, Q> D = Position - Focal; 16 | T Radius2 = pow2(Radius); 17 | T Fx2 = pow2(F.x); 18 | T Fy2 = pow2(F.y); 19 | 20 | T Numerator = (D.x * F.x + D.y * F.y) + sqrt(Radius2 * (pow2(D.x) + pow2(D.y)) - pow2(D.x * F.y - D.y * F.x)); 21 | T Denominator = Radius2 - (Fx2 + Fy2); 22 | return Numerator / Denominator; 23 | } 24 | 25 | template 26 | GLM_FUNC_QUALIFIER T linearGradient 27 | ( 28 | vec<2, T, Q> const& Point0, 29 | vec<2, T, Q> const& Point1, 30 | vec<2, T, Q> const& Position 31 | ) 32 | { 33 | vec<2, T, Q> Dist = Point1 - Point0; 34 | return (Dist.x * (Position.x - Point0.x) + Dist.y * (Position.y - Point0.y)) / glm::dot(Dist, Dist); 35 | } 36 | }//namespace glm 37 | -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementClock.cpp: -------------------------------------------------------------------------------- 1 | #include "wirePlacementClock.h" 2 | #include "wireObjectBase.h" 3 | 4 | namespace wireObjects { 5 | wirePlacementClock::wirePlacementClock() { 6 | 7 | } 8 | 9 | DWORD wirePlacementClock::init(TDShape* housing, int memoryVal) { 10 | this->housing = housing; 11 | this->memory = memoryVal; 12 | 13 | wireNode* _red = new wireNode(); 14 | _red->init(this, wireObjects::nodeType::NT_Bool, wireObjects::nodeColour::Red, { 0.25f, 0.25f, 0.05f }); 15 | this->nodes.push_back(_red); 16 | 17 | return 0x01; 18 | } 19 | 20 | DWORD wirePlacementClock::exec() { 21 | if (this->onTimeCountdown > 0) { 22 | this->onTimeCountdown--; 23 | } 24 | else { 25 | this->onTimeCountdown = this->memory; 26 | this->nodes[0]->setValue((int)(!(bool)this->nodes[0]->getOwnValue())); 27 | if ((bool)this->nodes[0]->getOwnValue()) { 28 | this->housing->Intergrity = 1.f; 29 | } 30 | else { 31 | this->housing->Intergrity = 0.f; 32 | } 33 | } 34 | 35 | return 0x01; 36 | } 37 | 38 | DWORD wirePlacementClock::usrExec() { 39 | 40 | return 0x01; 41 | } 42 | } -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/gtx/extend.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_extend 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER genType extend 7 | ( 8 | genType const& Origin, 9 | genType const& Source, 10 | genType const& Distance 11 | ) 12 | { 13 | return Origin + (Source - Origin) * Distance; 14 | } 15 | 16 | template 17 | GLM_FUNC_QUALIFIER vec<2, T, Q> extend 18 | ( 19 | vec<2, T, Q> const& Origin, 20 | vec<2, T, Q> const& Source, 21 | T const& Distance 22 | ) 23 | { 24 | return Origin + (Source - Origin) * Distance; 25 | } 26 | 27 | template 28 | GLM_FUNC_QUALIFIER vec<3, T, Q> extend 29 | ( 30 | vec<3, T, Q> const& Origin, 31 | vec<3, T, Q> const& Source, 32 | T const& Distance 33 | ) 34 | { 35 | return Origin + (Source - Origin) * Distance; 36 | } 37 | 38 | template 39 | GLM_FUNC_QUALIFIER vec<4, T, Q> extend 40 | ( 41 | vec<4, T, Q> const& Origin, 42 | vec<4, T, Q> const& Source, 43 | T const& Distance 44 | ) 45 | { 46 | return Origin + (Source - Origin) * Distance; 47 | } 48 | }//namespace glm 49 | -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementBomb.cpp: -------------------------------------------------------------------------------- 1 | #include "wireObjectBase.h" 2 | #include "wirePlacementBomb.h" 3 | 4 | namespace wireObjects { 5 | 6 | wirePlacementBomb::wirePlacementBomb() { 7 | 8 | } 9 | 10 | DWORD wirePlacementBomb::init(TDShape* housing, int memoryVal) { 11 | 12 | this->housing = housing; 13 | this->memory = memoryVal; 14 | 15 | wireNode* _red = new wireNode(); 16 | _red->init(this, wireObjects::nodeType::NT_Bool, wireObjects::nodeColour::Red, { 0.55f, 0.25f, 0.05f }); 17 | this->nodes.push_back(_red); 18 | 19 | return 0x01; 20 | } 21 | 22 | DWORD wirePlacementBomb::exec() { 23 | 24 | if ((bool)this->nodes[0]->getValue()) { 25 | td::Vec3 objectMin = this->housing->posMin; 26 | td::Vec3 objectMax = this->housing->posMax; 27 | td::Vec3 centerpoint = { objectMax.x - ((objectMax.x - objectMin.x) / 2), objectMax.y - ((objectMax.y - objectMin.y) / 2), objectMax.z - ((objectMax.z - objectMin.z) / 2) }; 28 | glb::TDcreateExplosion((uintptr_t)glb::scene, ¢erpoint, 3.f); 29 | this->softDispose(); 30 | } 31 | 32 | return 0x01; 33 | } 34 | 35 | DWORD wirePlacementBomb::usrExec() { 36 | 37 | return 0x01; 38 | } 39 | } -------------------------------------------------------------------------------- /diddlerInternal/wirePlacementButton.cpp: -------------------------------------------------------------------------------- 1 | #include "wireObjectBase.h" 2 | #include "wirePlacementButton.h" 3 | 4 | namespace wireObjects { 5 | 6 | wirePlacementButton::wirePlacementButton() { 7 | 8 | } 9 | 10 | DWORD wirePlacementButton::init(TDShape* housing, int memoryVal) { 11 | this->housing = housing; 12 | this->memory = memoryVal; 13 | 14 | wireNode* _red = new wireNode(); 15 | _red->init(this, wireObjects::nodeType::NT_Bool, wireObjects::nodeColour::Red, { 0.45f, 0.25f, 0.05f }); 16 | this->nodes.push_back(_red); 17 | 18 | return 0x01; 19 | } 20 | 21 | DWORD wirePlacementButton::exec() { 22 | 23 | if (this->onTimeCountdown > 0) { 24 | this->onTimeCountdown--; 25 | this->nodes[0]->setValue(1); 26 | this->housing->Intergrity = 1.f; 27 | } 28 | else { 29 | this->nodes[0]->setValue(0); 30 | this->housing->Intergrity = 0.f; 31 | } 32 | 33 | this->memory = this->onTimeCountdown; 34 | 35 | return 0x01; 36 | } 37 | 38 | DWORD wirePlacementButton::usrExec() { 39 | printf_s("exec called: %p\n", this); 40 | 41 | if (this->onTimeCountdown == 0) { 42 | this->onTimeCountdown = 30; 43 | } 44 | return 0x01; 45 | } 46 | } -------------------------------------------------------------------------------- /diddlerInternal/glm/test/core/core_force_xyzw_only.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_FORCE_XYZW_ONLY 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | static int test_comp() 11 | { 12 | int Error = 0; 13 | 14 | { 15 | glm::ivec1 const A(1); 16 | Error += A.x == 1 ? 0 : 1; 17 | } 18 | 19 | { 20 | glm::ivec2 const A(1, 2); 21 | Error += A.x == 1 ? 0 : 1; 22 | Error += A.y == 2 ? 0 : 1; 23 | } 24 | 25 | { 26 | glm::ivec3 const A(1, 2, 3); 27 | Error += A.x == 1 ? 0 : 1; 28 | Error += A.y == 2 ? 0 : 1; 29 | Error += A.z == 3 ? 0 : 1; 30 | } 31 | 32 | { 33 | glm::ivec4 const A(1, 2, 3, 4); 34 | Error += A.x == 1 ? 0 : 1; 35 | Error += A.y == 2 ? 0 : 1; 36 | Error += A.z == 3 ? 0 : 1; 37 | Error += A.w == 4 ? 0 : 1; 38 | } 39 | 40 | return Error; 41 | } 42 | 43 | static int test_constexpr() 44 | { 45 | int Error = 0; 46 | 47 | return Error; 48 | } 49 | 50 | int main() 51 | { 52 | int Error = 0; 53 | 54 | Error += test_comp(); 55 | Error += test_constexpr(); 56 | 57 | return Error; 58 | } 59 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/ext/matrix_common.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_common 2 | /// @file glm/ext/matrix_common.hpp 3 | /// 4 | /// @defgroup ext_matrix_common GLM_EXT_matrix_common 5 | /// @ingroup ext 6 | /// 7 | /// Defines functions for common matrix operations. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_matrix_common 12 | 13 | #pragma once 14 | 15 | #include "../detail/qualifier.hpp" 16 | #include "../detail/_fixes.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_EXT_matrix_transform extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup ext_matrix_common 25 | /// @{ 26 | 27 | template 28 | GLM_FUNC_DECL mat mix(mat const& x, mat const& y, mat const& a); 29 | 30 | template 31 | GLM_FUNC_DECL mat mix(mat const& x, mat const& y, U a); 32 | 33 | /// @} 34 | }//namespace glm 35 | 36 | #include "matrix_common.inl" 37 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/ext/quaternion_float.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_quaternion_float 2 | /// @file glm/ext/quaternion_float.hpp 3 | /// 4 | /// @defgroup ext_quaternion_float GLM_EXT_quaternion_float 5 | /// @ingroup ext 6 | /// 7 | /// Exposes single-precision floating point quaternion type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_quaternion_double 12 | /// @see ext_quaternion_float_precision 13 | /// @see ext_quaternion_common 14 | /// @see ext_quaternion_exponential 15 | /// @see ext_quaternion_geometric 16 | /// @see ext_quaternion_relational 17 | /// @see ext_quaternion_transform 18 | /// @see ext_quaternion_trigonometric 19 | 20 | #pragma once 21 | 22 | // Dependency: 23 | #include "../detail/type_quat.hpp" 24 | 25 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 26 | # pragma message("GLM: GLM_EXT_quaternion_float extension included") 27 | #endif 28 | 29 | namespace glm 30 | { 31 | /// @addtogroup ext_quaternion_float 32 | /// @{ 33 | 34 | /// Quaternion of single-precision floating-point numbers. 35 | typedef qua quat; 36 | 37 | /// @} 38 | } //namespace glm 39 | 40 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/ext/quaternion_double.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_quaternion_double 2 | /// @file glm/ext/quaternion_double.hpp 3 | /// 4 | /// @defgroup ext_quaternion_double GLM_EXT_quaternion_double 5 | /// @ingroup ext 6 | /// 7 | /// Exposes double-precision floating point quaternion type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_quaternion_float 12 | /// @see ext_quaternion_double_precision 13 | /// @see ext_quaternion_common 14 | /// @see ext_quaternion_exponential 15 | /// @see ext_quaternion_geometric 16 | /// @see ext_quaternion_relational 17 | /// @see ext_quaternion_transform 18 | /// @see ext_quaternion_trigonometric 19 | 20 | #pragma once 21 | 22 | // Dependency: 23 | #include "../detail/type_quat.hpp" 24 | 25 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 26 | # pragma message("GLM: GLM_EXT_quaternion_double extension included") 27 | #endif 28 | 29 | namespace glm 30 | { 31 | /// @addtogroup ext_quaternion_double 32 | /// @{ 33 | 34 | /// Quaternion of double-precision floating-point numbers. 35 | typedef qua dquat; 36 | 37 | /// @} 38 | } //namespace glm 39 | 40 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/ext/quaternion_trigonometric.inl: -------------------------------------------------------------------------------- 1 | #include "scalar_constants.hpp" 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER T angle(qua const& x) 7 | { 8 | if (abs(x.w) > cos_one_over_two()) 9 | { 10 | T const a = asin(sqrt(x.x * x.x + x.y * x.y + x.z * x.z)) * static_cast(2); 11 | if(x.w < static_cast(0)) 12 | return pi() * static_cast(2) - a; 13 | return a; 14 | } 15 | 16 | return acos(x.w) * static_cast(2); 17 | } 18 | 19 | template 20 | GLM_FUNC_QUALIFIER vec<3, T, Q> axis(qua const& x) 21 | { 22 | T const tmp1 = static_cast(1) - x.w * x.w; 23 | if(tmp1 <= static_cast(0)) 24 | return vec<3, T, Q>(0, 0, 1); 25 | T const tmp2 = static_cast(1) / sqrt(tmp1); 26 | return vec<3, T, Q>(x.x * tmp2, x.y * tmp2, x.z * tmp2); 27 | } 28 | 29 | template 30 | GLM_FUNC_QUALIFIER qua angleAxis(T const& angle, vec<3, T, Q> const& v) 31 | { 32 | T const a(angle); 33 | T const s = glm::sin(a * static_cast(0.5)); 34 | 35 | return qua(glm::cos(a * static_cast(0.5)), v * s); 36 | } 37 | }//namespace glm 38 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/ext/quaternion_relational.inl: -------------------------------------------------------------------------------- 1 | namespace glm 2 | { 3 | template 4 | GLM_FUNC_QUALIFIER vec<4, bool, Q> equal(qua const& x, qua const& y) 5 | { 6 | vec<4, bool, Q> Result; 7 | for(length_t i = 0; i < x.length(); ++i) 8 | Result[i] = x[i] == y[i]; 9 | return Result; 10 | } 11 | 12 | template 13 | GLM_FUNC_QUALIFIER vec<4, bool, Q> equal(qua const& x, qua const& y, T epsilon) 14 | { 15 | vec<4, T, Q> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w); 16 | return lessThan(abs(v), vec<4, T, Q>(epsilon)); 17 | } 18 | 19 | template 20 | GLM_FUNC_QUALIFIER vec<4, bool, Q> notEqual(qua const& x, qua const& y) 21 | { 22 | vec<4, bool, Q> Result; 23 | for(length_t i = 0; i < x.length(); ++i) 24 | Result[i] = x[i] != y[i]; 25 | return Result; 26 | } 27 | 28 | template 29 | GLM_FUNC_QUALIFIER vec<4, bool, Q> notEqual(qua const& x, qua const& y, T epsilon) 30 | { 31 | vec<4, T, Q> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w); 32 | return greaterThanEqual(abs(v), vec<4, T, Q>(epsilon)); 33 | } 34 | }//namespace glm 35 | 36 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/gtc/integer.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_integer 2 | 3 | namespace glm{ 4 | namespace detail 5 | { 6 | template 7 | struct compute_log2 8 | { 9 | GLM_FUNC_QUALIFIER static vec call(vec const& v) 10 | { 11 | //Equivalent to return findMSB(vec); but save one function call in ASM with VC 12 | //return findMSB(vec); 13 | return vec(detail::compute_findMSB_vec::call(v)); 14 | } 15 | }; 16 | 17 | # if GLM_HAS_BITSCAN_WINDOWS 18 | template 19 | struct compute_log2<4, int, Q, false, Aligned> 20 | { 21 | GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v) 22 | { 23 | vec<4, int, Q> Result; 24 | _BitScanReverse(reinterpret_cast(&Result.x), v.x); 25 | _BitScanReverse(reinterpret_cast(&Result.y), v.y); 26 | _BitScanReverse(reinterpret_cast(&Result.z), v.z); 27 | _BitScanReverse(reinterpret_cast(&Result.w), v.w); 28 | return Result; 29 | } 30 | }; 31 | # endif//GLM_HAS_BITSCAN_WINDOWS 32 | }//namespace detail 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /diddlerInternal/tgtDamage.cpp: -------------------------------------------------------------------------------- 1 | #include "Global.h" 2 | #include "tgtDamage.h" 3 | #include "Raycaster.h" 4 | #include "drawCube.h" 5 | #include "dotProjector.h" 6 | 7 | tgt_damage::tgt_damage() { 8 | 9 | } 10 | 11 | DWORD tgt_damage::exec() { 12 | 13 | td::Color red{ 1.f, 0.f, 0.f, 1.f }; 14 | td::Color green{ 0.f, 1.f, 0.f, 1.f }; 15 | RaycastFilter rcf = {}; 16 | 17 | if (fireConst) { 18 | fireOnceActive = true; 19 | } 20 | 21 | dotProjector::pixelResponse* pixelResponse = dotProjector::projectDotMatrix(res, flRadius, 1.f, false, (glm::quat*)&glb::player->cameraQuat, glb::player->cameraPosition, { 0, 0, -1 }, { 0, 1, 0 }, &rcf); 22 | 23 | for (int i = 0; i < pixelResponse->size; i++) { 24 | dotProjector::rayPixel rp = pixelResponse->data[i]; 25 | 26 | if (rp.dist <= maxRange) { 27 | if (glb::player->isAttacking == true) { 28 | glb::oWrappedDamage(glb::scene, &rp.worldPos, holeSize, holeSize, 0, 0); 29 | drawCube(rp.worldPos, 0.02, red); 30 | } 31 | else { 32 | drawCube(rp.worldPos, 0.02, green); 33 | } 34 | } 35 | } 36 | 37 | 38 | 39 | return 0x01; 40 | } -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_vector_int1_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::i8vec1) == 1, "int8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::i16vec1) == 2, "int16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::i32vec1) == 4, "int32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::i64vec1) == 8, "int64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_size() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::i8vec1) == 1 ? 0 : 1; 15 | Error += sizeof(glm::i16vec1) == 2 ? 0 : 1; 16 | Error += sizeof(glm::i32vec1) == 4 ? 0 : 1; 17 | Error += sizeof(glm::i64vec1) == 8 ? 0 : 1; 18 | 19 | return Error; 20 | } 21 | 22 | static int test_comp() 23 | { 24 | int Error = 0; 25 | 26 | Error += sizeof(glm::i8vec1) < sizeof(glm::i16vec1) ? 0 : 1; 27 | Error += sizeof(glm::i16vec1) < sizeof(glm::i32vec1) ? 0 : 1; 28 | Error += sizeof(glm::i32vec1) < sizeof(glm::i64vec1) ? 0 : 1; 29 | 30 | return Error; 31 | } 32 | 33 | int main() 34 | { 35 | int Error = 0; 36 | 37 | Error += test_size(); 38 | Error += test_comp(); 39 | 40 | return Error; 41 | } 42 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_vector_int4_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::i8vec4) == 4, "int8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::i16vec4) == 8, "int16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::i32vec4) == 16, "int32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::i64vec4) == 32, "int64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_size() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::i8vec4) == 4 ? 0 : 1; 15 | Error += sizeof(glm::i16vec4) == 8 ? 0 : 1; 16 | Error += sizeof(glm::i32vec4) == 16 ? 0 : 1; 17 | Error += sizeof(glm::i64vec4) == 32 ? 0 : 1; 18 | 19 | return Error; 20 | } 21 | 22 | static int test_comp() 23 | { 24 | int Error = 0; 25 | 26 | Error += sizeof(glm::i8vec4) < sizeof(glm::i16vec4) ? 0 : 1; 27 | Error += sizeof(glm::i16vec4) < sizeof(glm::i32vec4) ? 0 : 1; 28 | Error += sizeof(glm::i32vec4) < sizeof(glm::i64vec4) ? 0 : 1; 29 | 30 | return Error; 31 | } 32 | 33 | int main() 34 | { 35 | int Error = 0; 36 | 37 | Error += test_size(); 38 | Error += test_comp(); 39 | 40 | return Error; 41 | } 42 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_vector_uint2_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::u8vec2) == 2, "int8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::u16vec2) == 4, "int16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::u32vec2) == 8, "int32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::u64vec2) == 16, "int64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_size() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::u8vec2) == 2 ? 0 : 1; 15 | Error += sizeof(glm::u16vec2) == 4 ? 0 : 1; 16 | Error += sizeof(glm::u32vec2) == 8 ? 0 : 1; 17 | Error += sizeof(glm::u64vec2) == 16 ? 0 : 1; 18 | 19 | return Error; 20 | } 21 | 22 | static int test_comp() 23 | { 24 | int Error = 0; 25 | 26 | Error += sizeof(glm::u8vec2) < sizeof(glm::u16vec2) ? 0 : 1; 27 | Error += sizeof(glm::u16vec2) < sizeof(glm::u32vec2) ? 0 : 1; 28 | Error += sizeof(glm::u32vec2) < sizeof(glm::u64vec2) ? 0 : 1; 29 | 30 | return Error; 31 | } 32 | 33 | int main() 34 | { 35 | int Error = 0; 36 | 37 | Error += test_size(); 38 | Error += test_comp(); 39 | 40 | return Error; 41 | } 42 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_vector_int2_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::i8vec2) == 2, "int8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::i16vec2) == 4, "int16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::i32vec2) == 8, "int32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::i64vec2) == 16, "int64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_size() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::i8vec2) == 2 ? 0 : 1; 15 | Error += sizeof(glm::i16vec2) == 4 ? 0 : 1; 16 | Error += sizeof(glm::i32vec2) == 8 ? 0 : 1; 17 | Error += sizeof(glm::i64vec2) == 16 ? 0 : 1; 18 | 19 | return Error; 20 | } 21 | 22 | static int test_comp() 23 | { 24 | int Error = 0; 25 | 26 | Error += sizeof(glm::i8vec2) < sizeof(glm::i16vec2) ? 0 : 1; 27 | Error += sizeof(glm::i16vec2) < sizeof(glm::i32vec2) ? 0 : 1; 28 | Error += sizeof(glm::i32vec2) < sizeof(glm::i64vec2) ? 0 : 1; 29 | 30 | return Error; 31 | } 32 | 33 | int main() 34 | { 35 | int Error = 0; 36 | 37 | Error += test_size(); 38 | Error += test_comp(); 39 | 40 | return Error; 41 | } 42 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_vector_int3_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::i8vec3) == 3, "int8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::i16vec3) == 6, "int16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::i32vec3) == 12, "int32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::i64vec3) == 24, "int64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_size() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::i8vec3) == 3 ? 0 : 1; 15 | Error += sizeof(glm::i16vec3) == 6 ? 0 : 1; 16 | Error += sizeof(glm::i32vec3) == 12 ? 0 : 1; 17 | Error += sizeof(glm::i64vec3) == 24 ? 0 : 1; 18 | 19 | return Error; 20 | } 21 | 22 | static int test_comp() 23 | { 24 | int Error = 0; 25 | 26 | Error += sizeof(glm::i8vec3) < sizeof(glm::i16vec3) ? 0 : 1; 27 | Error += sizeof(glm::i16vec3) < sizeof(glm::i32vec3) ? 0 : 1; 28 | Error += sizeof(glm::i32vec3) < sizeof(glm::i64vec3) ? 0 : 1; 29 | 30 | return Error; 31 | } 32 | 33 | int main() 34 | { 35 | int Error = 0; 36 | 37 | Error += test_size(); 38 | Error += test_comp(); 39 | 40 | return Error; 41 | } 42 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_vector_uint3_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::u8vec3) == 3, "int8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::u16vec3) == 6, "int16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::u32vec3) == 12, "int32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::u64vec3) == 24, "int64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_size() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::u8vec3) == 3 ? 0 : 1; 15 | Error += sizeof(glm::u16vec3) == 6 ? 0 : 1; 16 | Error += sizeof(glm::u32vec3) == 12 ? 0 : 1; 17 | Error += sizeof(glm::u64vec3) == 24 ? 0 : 1; 18 | 19 | return Error; 20 | } 21 | 22 | static int test_comp() 23 | { 24 | int Error = 0; 25 | 26 | Error += sizeof(glm::u8vec3) < sizeof(glm::u16vec3) ? 0 : 1; 27 | Error += sizeof(glm::u16vec3) < sizeof(glm::u32vec3) ? 0 : 1; 28 | Error += sizeof(glm::u32vec3) < sizeof(glm::u64vec3) ? 0 : 1; 29 | 30 | return Error; 31 | } 32 | 33 | int main() 34 | { 35 | int Error = 0; 36 | 37 | Error += test_size(); 38 | Error += test_comp(); 39 | 40 | return Error; 41 | } 42 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_vector_uint4_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::u8vec4) == 4, "int8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::u16vec4) == 8, "int16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::u32vec4) == 16, "int32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::u64vec4) == 32, "int64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_size() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::u8vec4) == 4 ? 0 : 1; 15 | Error += sizeof(glm::u16vec4) == 8 ? 0 : 1; 16 | Error += sizeof(glm::u32vec4) == 16 ? 0 : 1; 17 | Error += sizeof(glm::u64vec4) == 32 ? 0 : 1; 18 | 19 | return Error; 20 | } 21 | 22 | static int test_comp() 23 | { 24 | int Error = 0; 25 | 26 | Error += sizeof(glm::u8vec4) < sizeof(glm::u16vec4) ? 0 : 1; 27 | Error += sizeof(glm::u16vec4) < sizeof(glm::u32vec4) ? 0 : 1; 28 | Error += sizeof(glm::u32vec4) < sizeof(glm::u64vec4) ? 0 : 1; 29 | 30 | return Error; 31 | } 32 | 33 | int main() 34 | { 35 | int Error = 0; 36 | 37 | Error += test_size(); 38 | Error += test_comp(); 39 | 40 | return Error; 41 | } 42 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/gtc/integer.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_integer 2 | /// @file glm/gtc/integer.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_integer (dependence) 6 | /// 7 | /// @defgroup gtc_integer GLM_GTC_integer 8 | /// @ingroup gtc 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// @brief Allow to perform bit operations on integer values 13 | 14 | #pragma once 15 | 16 | // Dependencies 17 | #include "../detail/setup.hpp" 18 | #include "../detail/qualifier.hpp" 19 | #include "../common.hpp" 20 | #include "../integer.hpp" 21 | #include "../exponential.hpp" 22 | #include "../ext/scalar_common.hpp" 23 | #include "../ext/vector_common.hpp" 24 | #include 25 | 26 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 27 | # pragma message("GLM: GLM_GTC_integer extension included") 28 | #endif 29 | 30 | namespace glm 31 | { 32 | /// @addtogroup gtc_integer 33 | /// @{ 34 | 35 | /// Returns the log2 of x for integer values. Usefull to compute mipmap count from the texture size. 36 | /// @see gtc_integer 37 | template 38 | GLM_FUNC_DECL genIUType log2(genIUType x); 39 | 40 | /// @} 41 | } //namespace glm 42 | 43 | #include "integer.inl" 44 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/ext/ext_vector_uint1_sized.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #if GLM_HAS_STATIC_ASSERT 4 | static_assert(sizeof(glm::u8vec1) == 1, "uint8 size isn't 1 byte on this platform"); 5 | static_assert(sizeof(glm::u16vec1) == 2, "uint16 size isn't 2 bytes on this platform"); 6 | static_assert(sizeof(glm::u32vec1) == 4, "uint32 size isn't 4 bytes on this platform"); 7 | static_assert(sizeof(glm::u64vec1) == 8, "uint64 size isn't 8 bytes on this platform"); 8 | #endif 9 | 10 | static int test_size() 11 | { 12 | int Error = 0; 13 | 14 | Error += sizeof(glm::u8vec1) == 1 ? 0 : 1; 15 | Error += sizeof(glm::u16vec1) == 2 ? 0 : 1; 16 | Error += sizeof(glm::u32vec1) == 4 ? 0 : 1; 17 | Error += sizeof(glm::u64vec1) == 8 ? 0 : 1; 18 | 19 | return Error; 20 | } 21 | 22 | static int test_comp() 23 | { 24 | int Error = 0; 25 | 26 | Error += sizeof(glm::u8vec1) < sizeof(glm::u16vec1) ? 0 : 1; 27 | Error += sizeof(glm::u16vec1) < sizeof(glm::u32vec1) ? 0 : 1; 28 | Error += sizeof(glm::u32vec1) < sizeof(glm::u64vec1) ? 0 : 1; 29 | 30 | return Error; 31 | } 32 | 33 | int main() 34 | { 35 | int Error = 0; 36 | 37 | Error += test_size(); 38 | Error += test_comp(); 39 | 40 | return Error; 41 | } 42 | -------------------------------------------------------------------------------- /diddlerInternal/glm/test/gtx/gtx_scalar_multiplication.cpp: -------------------------------------------------------------------------------- 1 | #define GLM_ENABLE_EXPERIMENTAL 2 | #include 3 | #include 4 | #include 5 | 6 | #if GLM_HAS_TEMPLATE_ALIASES && !(GLM_COMPILER & GLM_COMPILER_GCC) 7 | #include 8 | 9 | int main() 10 | { 11 | int Error(0); 12 | glm::vec3 v(0.5, 3.1, -9.1); 13 | 14 | Error += glm::all(glm::equal(v, 1.0 * v, glm::epsilon())) ? 0 : 1; 15 | Error += glm::all(glm::equal(v, 1 * v, glm::epsilon())) ? 0 : 1; 16 | Error += glm::all(glm::equal(v, 1u * v, glm::epsilon())) ? 0 : 1; 17 | 18 | glm::mat3 m(1, 2, 3, 4, 5, 6, 7, 8, 9); 19 | glm::vec3 w = 0.5f * m * v; 20 | 21 | Error += glm::all(glm::equal((m*v)/2, w, glm::epsilon())) ? 0 : 1; 22 | Error += glm::all(glm::equal(m*(v/2), w, glm::epsilon())) ? 0 : 1; 23 | Error += glm::all(glm::equal((m/2)*v, w, glm::epsilon())) ? 0 : 1; 24 | Error += glm::all(glm::equal((0.5*m)*v, w, glm::epsilon())) ? 0 : 1; 25 | Error += glm::all(glm::equal(0.5*(m*v), w, glm::epsilon())) ? 0 : 1; 26 | 27 | return Error; 28 | } 29 | 30 | #else 31 | 32 | int main() 33 | { 34 | return 0; 35 | } 36 | 37 | #endif 38 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/ext/scalar_constants.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_scalar_constants 2 | /// @file glm/ext/scalar_constants.hpp 3 | /// 4 | /// @defgroup ext_scalar_constants GLM_EXT_scalar_constants 5 | /// @ingroup ext 6 | /// 7 | /// Provides a list of constants and precomputed useful values. 8 | /// 9 | /// Include to use the features of this extension. 10 | 11 | #pragma once 12 | 13 | // Dependencies 14 | #include "../detail/setup.hpp" 15 | 16 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 17 | # pragma message("GLM: GLM_EXT_scalar_constants extension included") 18 | #endif 19 | 20 | namespace glm 21 | { 22 | /// @addtogroup ext_scalar_constants 23 | /// @{ 24 | 25 | /// Return the epsilon constant for floating point types. 26 | template 27 | GLM_FUNC_DECL GLM_CONSTEXPR genType epsilon(); 28 | 29 | /// Return the pi constant for floating point types. 30 | template 31 | GLM_FUNC_DECL GLM_CONSTEXPR genType pi(); 32 | 33 | /// Return the value of cos(1 / 2) for floating point types. 34 | template 35 | GLM_FUNC_DECL GLM_CONSTEXPR genType cos_one_over_two(); 36 | 37 | /// @} 38 | } //namespace glm 39 | 40 | #include "scalar_constants.inl" 41 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/gtx/normal.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_normal 2 | /// @file glm/gtx/normal.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_extented_min_max (dependence) 6 | /// 7 | /// @defgroup gtx_normal GLM_GTX_normal 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Compute the normal of a triangle. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # ifndef GLM_ENABLE_EXPERIMENTAL 21 | # pragma message("GLM: GLM_GTX_normal is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 22 | # else 23 | # pragma message("GLM: GLM_GTX_normal extension included") 24 | # endif 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_normal 30 | /// @{ 31 | 32 | /// Computes triangle normal from triangle points. 33 | /// 34 | /// @see gtx_normal 35 | template 36 | GLM_FUNC_DECL vec<3, T, Q> triangleNormal(vec<3, T, Q> const& p1, vec<3, T, Q> const& p2, vec<3, T, Q> const& p3); 37 | 38 | /// @} 39 | }//namespace glm 40 | 41 | #include "normal.inl" 42 | -------------------------------------------------------------------------------- /diddlerInternal/glm/glm/gtx/mixed_product.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_mixed_product 2 | /// @file glm/gtx/mixed_product.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_mixed_product GLM_GTX_mixed_producte 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Mixed product of 3 vectors. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 19 | # ifndef GLM_ENABLE_EXPERIMENTAL 20 | # pragma message("GLM: GLM_GTX_mixed_product is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it.") 21 | # else 22 | # pragma message("GLM: GLM_GTX_mixed_product extension included") 23 | # endif 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_mixed_product 29 | /// @{ 30 | 31 | /// @brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension) 32 | template 33 | GLM_FUNC_DECL T mixedProduct( 34 | vec<3, T, Q> const& v1, 35 | vec<3, T, Q> const& v2, 36 | vec<3, T, Q> const& v3); 37 | 38 | /// @} 39 | }// namespace glm 40 | 41 | #include "mixed_product.inl" 42 | --------------------------------------------------------------------------------