├── .gitignore ├── CMakeLists.txt ├── GenerateProject.bat ├── MitoEngine2D.cmake ├── PremakeToCMake.bat ├── README.md ├── assets ├── fonts │ ├── arial.ttf │ └── charriot.ttf ├── images │ ├── RoundedSquare.png │ ├── ball.png │ ├── brick.png │ ├── brickL.png │ ├── explosion.png │ ├── icon.png │ └── paddle.png ├── levels │ ├── game.lua │ ├── lose.lua │ ├── main.lua │ └── menu.lua ├── prefabs │ ├── brick.lua │ └── explosionFX.lua ├── scripts │ ├── GameManager.lua │ ├── ball.lua │ ├── brick.lua │ ├── playbutton.lua │ ├── player.lua │ └── score.lua ├── settings │ └── settings.lua └── sounds │ ├── ball_hit.wav │ ├── brick_destroyed.wav │ ├── game_music.ogg │ ├── level_up.wav │ ├── menu_music.ogg │ └── menu_select.wav ├── cmake ├── LICENSE.txt ├── README.md ├── _manifest.lua ├── _preload.lua ├── cmake.lua ├── cmake_project.lua └── cmake_workspace.lua ├── imgui.ini ├── libs ├── SDL2 │ ├── BUGS.txt │ ├── COPYING.txt │ ├── README-SDL.txt │ ├── README.txt │ ├── WhatsNew.txt │ ├── cmake │ │ ├── sdl2-config-version.cmake │ │ └── sdl2-config.cmake │ ├── docs │ │ ├── CONTRIBUTING.md │ │ ├── README-android.md │ │ ├── README-cmake.md │ │ ├── README-directfb.md │ │ ├── README-dynapi.md │ │ ├── README-emscripten.md │ │ ├── README-gdk.md │ │ ├── README-gesture.md │ │ ├── README-git.md │ │ ├── README-hg.md │ │ ├── README-ios.md │ │ ├── README-kmsbsd.md │ │ ├── README-linux.md │ │ ├── README-macos.md │ │ ├── README-n3ds.md │ │ ├── README-nacl.md │ │ ├── README-ngage.md │ │ ├── README-os2.md │ │ ├── README-pandora.md │ │ ├── README-platforms.md │ │ ├── README-porting.md │ │ ├── README-ps2.md │ │ ├── README-psp.md │ │ ├── README-raspberrypi.md │ │ ├── README-riscos.md │ │ ├── README-touch.md │ │ ├── README-versions.md │ │ ├── README-visualc.md │ │ ├── README-vita.md │ │ ├── README-wince.md │ │ ├── README-windows.md │ │ ├── README-winrt.md │ │ ├── README.md │ │ ├── doxyfile │ │ └── release_checklist.md │ ├── include │ │ ├── SDL.h │ │ ├── SDL_assert.h │ │ ├── SDL_atomic.h │ │ ├── SDL_audio.h │ │ ├── SDL_bits.h │ │ ├── SDL_blendmode.h │ │ ├── SDL_clipboard.h │ │ ├── SDL_config.h │ │ ├── SDL_cpuinfo.h │ │ ├── SDL_egl.h │ │ ├── SDL_endian.h │ │ ├── SDL_error.h │ │ ├── SDL_events.h │ │ ├── SDL_filesystem.h │ │ ├── SDL_gamecontroller.h │ │ ├── SDL_gesture.h │ │ ├── SDL_guid.h │ │ ├── SDL_haptic.h │ │ ├── SDL_hidapi.h │ │ ├── SDL_hints.h │ │ ├── SDL_joystick.h │ │ ├── SDL_keyboard.h │ │ ├── SDL_keycode.h │ │ ├── SDL_loadso.h │ │ ├── SDL_locale.h │ │ ├── SDL_log.h │ │ ├── SDL_main.h │ │ ├── SDL_messagebox.h │ │ ├── SDL_metal.h │ │ ├── SDL_misc.h │ │ ├── SDL_mouse.h │ │ ├── SDL_mutex.h │ │ ├── SDL_name.h │ │ ├── SDL_opengl.h │ │ ├── SDL_opengl_glext.h │ │ ├── SDL_opengles.h │ │ ├── SDL_opengles2.h │ │ ├── SDL_opengles2_gl2.h │ │ ├── SDL_opengles2_gl2ext.h │ │ ├── SDL_opengles2_gl2platform.h │ │ ├── SDL_opengles2_khrplatform.h │ │ ├── SDL_pixels.h │ │ ├── SDL_platform.h │ │ ├── SDL_power.h │ │ ├── SDL_quit.h │ │ ├── SDL_rect.h │ │ ├── SDL_render.h │ │ ├── SDL_revision.h │ │ ├── SDL_rwops.h │ │ ├── SDL_scancode.h │ │ ├── SDL_sensor.h │ │ ├── SDL_shape.h │ │ ├── SDL_stdinc.h │ │ ├── SDL_surface.h │ │ ├── SDL_system.h │ │ ├── SDL_syswm.h │ │ ├── SDL_test.h │ │ ├── SDL_test_assert.h │ │ ├── SDL_test_common.h │ │ ├── SDL_test_compare.h │ │ ├── SDL_test_crc32.h │ │ ├── SDL_test_font.h │ │ ├── SDL_test_fuzzer.h │ │ ├── SDL_test_harness.h │ │ ├── SDL_test_images.h │ │ ├── SDL_test_log.h │ │ ├── SDL_test_md5.h │ │ ├── SDL_test_memory.h │ │ ├── SDL_test_random.h │ │ ├── SDL_thread.h │ │ ├── SDL_timer.h │ │ ├── SDL_touch.h │ │ ├── SDL_types.h │ │ ├── SDL_version.h │ │ ├── SDL_video.h │ │ ├── SDL_vulkan.h │ │ ├── begin_code.h │ │ └── close_code.h │ └── lib │ │ ├── x64 │ │ ├── SDL2.dll │ │ ├── SDL2.lib │ │ ├── SDL2main.lib │ │ └── SDL2test.lib │ │ └── x86 │ │ ├── SDL2.dll │ │ ├── SDL2.lib │ │ ├── SDL2main.lib │ │ └── SDL2test.lib ├── SDL2_image │ ├── CHANGES.txt │ ├── LICENSE.txt │ ├── README.txt │ ├── cmake │ │ ├── sdl2_image-config-version.cmake │ │ └── sdl2_image-config.cmake │ ├── include │ │ └── SDL_image.h │ └── lib │ │ ├── x64 │ │ ├── SDL2_image.dll │ │ ├── SDL2_image.lib │ │ └── optional │ │ │ ├── LICENSE.avif.txt │ │ │ ├── LICENSE.dav1d.txt │ │ │ ├── LICENSE.tiff.txt │ │ │ ├── LICENSE.webp.txt │ │ │ ├── libavif-16.dll │ │ │ ├── libtiff-5.dll │ │ │ ├── libwebp-7.dll │ │ │ └── libwebpdemux-2.dll │ │ └── x86 │ │ ├── SDL2_image.dll │ │ ├── SDL2_image.lib │ │ └── optional │ │ ├── LICENSE.avif.txt │ │ ├── LICENSE.dav1d.txt │ │ ├── LICENSE.tiff.txt │ │ ├── LICENSE.webp.txt │ │ ├── libavif-16.dll │ │ ├── libtiff-5.dll │ │ ├── libwebp-7.dll │ │ └── libwebpdemux-2.dll ├── SDL2_mixer │ ├── CHANGES.txt │ ├── LICENSE.txt │ ├── README.txt │ ├── cmake │ │ ├── sdl2_mixer-config-version.cmake │ │ └── sdl2_mixer-config.cmake │ ├── include │ │ └── SDL_mixer.h │ └── lib │ │ ├── x64 │ │ ├── SDL2_mixer.dll │ │ ├── SDL2_mixer.lib │ │ └── optional │ │ │ ├── LICENSE.gme.txt │ │ │ ├── LICENSE.ogg-vorbis.txt │ │ │ ├── LICENSE.opus.txt │ │ │ ├── LICENSE.opusfile.txt │ │ │ ├── LICENSE.wavpack.txt │ │ │ ├── LICENSE.xmp.txt │ │ │ ├── libgme.dll │ │ │ ├── libogg-0.dll │ │ │ ├── libopus-0.dll │ │ │ ├── libopusfile-0.dll │ │ │ ├── libwavpack-1.dll │ │ │ └── libxmp.dll │ │ └── x86 │ │ ├── SDL2_mixer.dll │ │ ├── SDL2_mixer.lib │ │ └── optional │ │ ├── LICENSE.gme.txt │ │ ├── LICENSE.ogg-vorbis.txt │ │ ├── LICENSE.opus.txt │ │ ├── LICENSE.opusfile.txt │ │ ├── LICENSE.wavpack.txt │ │ ├── LICENSE.xmp.txt │ │ ├── libgme.dll │ │ ├── libogg-0.dll │ │ ├── libopus-0.dll │ │ ├── libopusfile-0.dll │ │ ├── libwavpack-1.dll │ │ └── libxmp.dll ├── SDL2_ttf │ ├── CHANGES.txt │ ├── LICENSE.txt │ ├── README.txt │ ├── cmake │ │ ├── sdl2_ttf-config-version.cmake │ │ └── sdl2_ttf-config.cmake │ ├── include │ │ └── SDL_ttf.h │ └── lib │ │ ├── x64 │ │ ├── LICENSE.freetype.txt │ │ ├── LICENSE.harfbuzz.txt │ │ ├── LICENSE.zlib.txt │ │ ├── SDL2_ttf.dll │ │ └── SDL2_ttf.lib │ │ └── x86 │ │ ├── LICENSE.freetype.txt │ │ ├── LICENSE.harfbuzz.txt │ │ ├── LICENSE.zlib.txt │ │ ├── SDL2_ttf.dll │ │ └── SDL2_ttf.lib ├── glm │ ├── CMakeLists.txt │ ├── common.hpp │ ├── copying.txt │ ├── detail │ │ ├── _features.hpp │ │ ├── _fixes.hpp │ │ ├── _noise.hpp │ │ ├── _swizzle.hpp │ │ ├── _swizzle_func.hpp │ │ ├── _vectorize.hpp │ │ ├── compute_common.hpp │ │ ├── compute_vector_decl.hpp │ │ ├── compute_vector_relational.hpp │ │ ├── func_common.inl │ │ ├── func_common_simd.inl │ │ ├── func_exponential.inl │ │ ├── func_exponential_simd.inl │ │ ├── func_geometric.inl │ │ ├── func_geometric_simd.inl │ │ ├── func_integer.inl │ │ ├── func_integer_simd.inl │ │ ├── func_matrix.inl │ │ ├── func_matrix_simd.inl │ │ ├── func_packing.inl │ │ ├── func_packing_simd.inl │ │ ├── func_trigonometric.inl │ │ ├── func_trigonometric_simd.inl │ │ ├── func_vector_relational.inl │ │ ├── func_vector_relational_simd.inl │ │ ├── glm.cpp │ │ ├── qualifier.hpp │ │ ├── setup.hpp │ │ ├── type_float.hpp │ │ ├── type_half.hpp │ │ ├── type_half.inl │ │ ├── type_mat2x2.hpp │ │ ├── type_mat2x2.inl │ │ ├── type_mat2x3.hpp │ │ ├── type_mat2x3.inl │ │ ├── type_mat2x4.hpp │ │ ├── type_mat2x4.inl │ │ ├── type_mat3x2.hpp │ │ ├── type_mat3x2.inl │ │ ├── type_mat3x3.hpp │ │ ├── type_mat3x3.inl │ │ ├── type_mat3x4.hpp │ │ ├── type_mat3x4.inl │ │ ├── type_mat4x2.hpp │ │ ├── type_mat4x2.inl │ │ ├── type_mat4x3.hpp │ │ ├── type_mat4x3.inl │ │ ├── type_mat4x4.hpp │ │ ├── type_mat4x4.inl │ │ ├── type_mat4x4_simd.inl │ │ ├── type_quat.hpp │ │ ├── type_quat.inl │ │ ├── type_quat_simd.inl │ │ ├── type_vec1.hpp │ │ ├── type_vec1.inl │ │ ├── type_vec2.hpp │ │ ├── type_vec2.inl │ │ ├── type_vec3.hpp │ │ ├── type_vec3.inl │ │ ├── type_vec4.hpp │ │ ├── type_vec4.inl │ │ └── type_vec4_simd.inl │ ├── exponential.hpp │ ├── ext.hpp │ ├── ext │ │ ├── _matrix_vectorize.hpp │ │ ├── matrix_clip_space.hpp │ │ ├── matrix_clip_space.inl │ │ ├── matrix_common.hpp │ │ ├── matrix_common.inl │ │ ├── matrix_double2x2.hpp │ │ ├── matrix_double2x2_precision.hpp │ │ ├── matrix_double2x3.hpp │ │ ├── matrix_double2x3_precision.hpp │ │ ├── matrix_double2x4.hpp │ │ ├── matrix_double2x4_precision.hpp │ │ ├── matrix_double3x2.hpp │ │ ├── matrix_double3x2_precision.hpp │ │ ├── matrix_double3x3.hpp │ │ ├── matrix_double3x3_precision.hpp │ │ ├── matrix_double3x4.hpp │ │ ├── matrix_double3x4_precision.hpp │ │ ├── matrix_double4x2.hpp │ │ ├── matrix_double4x2_precision.hpp │ │ ├── matrix_double4x3.hpp │ │ ├── matrix_double4x3_precision.hpp │ │ ├── matrix_double4x4.hpp │ │ ├── matrix_double4x4_precision.hpp │ │ ├── matrix_float2x2.hpp │ │ ├── matrix_float2x2_precision.hpp │ │ ├── matrix_float2x3.hpp │ │ ├── matrix_float2x3_precision.hpp │ │ ├── matrix_float2x4.hpp │ │ ├── matrix_float2x4_precision.hpp │ │ ├── matrix_float3x2.hpp │ │ ├── matrix_float3x2_precision.hpp │ │ ├── matrix_float3x3.hpp │ │ ├── matrix_float3x3_precision.hpp │ │ ├── matrix_float3x4.hpp │ │ ├── matrix_float3x4_precision.hpp │ │ ├── matrix_float4x2.hpp │ │ ├── matrix_float4x2_precision.hpp │ │ ├── matrix_float4x3.hpp │ │ ├── matrix_float4x3_precision.hpp │ │ ├── matrix_float4x4.hpp │ │ ├── matrix_float4x4_precision.hpp │ │ ├── matrix_int2x2.hpp │ │ ├── matrix_int2x2_sized.hpp │ │ ├── matrix_int2x3.hpp │ │ ├── matrix_int2x3_sized.hpp │ │ ├── matrix_int2x4.hpp │ │ ├── matrix_int2x4_sized.hpp │ │ ├── matrix_int3x2.hpp │ │ ├── matrix_int3x2_sized.hpp │ │ ├── matrix_int3x3.hpp │ │ ├── matrix_int3x3_sized.hpp │ │ ├── matrix_int3x4.hpp │ │ ├── matrix_int3x4_sized.hpp │ │ ├── matrix_int4x2.hpp │ │ ├── matrix_int4x2_sized.hpp │ │ ├── matrix_int4x3.hpp │ │ ├── matrix_int4x3_sized.hpp │ │ ├── matrix_int4x4.hpp │ │ ├── matrix_int4x4_sized.hpp │ │ ├── matrix_integer.hpp │ │ ├── matrix_integer.inl │ │ ├── matrix_projection.hpp │ │ ├── matrix_projection.inl │ │ ├── matrix_relational.hpp │ │ ├── matrix_relational.inl │ │ ├── matrix_transform.hpp │ │ ├── matrix_transform.inl │ │ ├── matrix_uint2x2.hpp │ │ ├── matrix_uint2x2_sized.hpp │ │ ├── matrix_uint2x3.hpp │ │ ├── matrix_uint2x3_sized.hpp │ │ ├── matrix_uint2x4.hpp │ │ ├── matrix_uint2x4_sized.hpp │ │ ├── matrix_uint3x2.hpp │ │ ├── matrix_uint3x2_sized.hpp │ │ ├── matrix_uint3x3.hpp │ │ ├── matrix_uint3x3_sized.hpp │ │ ├── matrix_uint3x4.hpp │ │ ├── matrix_uint3x4_sized.hpp │ │ ├── matrix_uint4x2.hpp │ │ ├── matrix_uint4x2_sized.hpp │ │ ├── matrix_uint4x3.hpp │ │ ├── matrix_uint4x3_sized.hpp │ │ ├── matrix_uint4x4.hpp │ │ ├── matrix_uint4x4_sized.hpp │ │ ├── quaternion_common.hpp │ │ ├── quaternion_common.inl │ │ ├── quaternion_common_simd.inl │ │ ├── quaternion_double.hpp │ │ ├── quaternion_double_precision.hpp │ │ ├── quaternion_exponential.hpp │ │ ├── quaternion_exponential.inl │ │ ├── quaternion_float.hpp │ │ ├── quaternion_float_precision.hpp │ │ ├── quaternion_geometric.hpp │ │ ├── quaternion_geometric.inl │ │ ├── quaternion_relational.hpp │ │ ├── quaternion_relational.inl │ │ ├── quaternion_transform.hpp │ │ ├── quaternion_transform.inl │ │ ├── quaternion_trigonometric.hpp │ │ ├── quaternion_trigonometric.inl │ │ ├── scalar_common.hpp │ │ ├── scalar_common.inl │ │ ├── scalar_constants.hpp │ │ ├── scalar_constants.inl │ │ ├── scalar_int_sized.hpp │ │ ├── scalar_integer.hpp │ │ ├── scalar_integer.inl │ │ ├── scalar_packing.hpp │ │ ├── scalar_packing.inl │ │ ├── scalar_reciprocal.hpp │ │ ├── scalar_reciprocal.inl │ │ ├── scalar_relational.hpp │ │ ├── scalar_relational.inl │ │ ├── scalar_uint_sized.hpp │ │ ├── scalar_ulp.hpp │ │ ├── scalar_ulp.inl │ │ ├── vector_bool1.hpp │ │ ├── vector_bool1_precision.hpp │ │ ├── vector_bool2.hpp │ │ ├── vector_bool2_precision.hpp │ │ ├── vector_bool3.hpp │ │ ├── vector_bool3_precision.hpp │ │ ├── vector_bool4.hpp │ │ ├── vector_bool4_precision.hpp │ │ ├── vector_common.hpp │ │ ├── vector_common.inl │ │ ├── vector_double1.hpp │ │ ├── vector_double1_precision.hpp │ │ ├── vector_double2.hpp │ │ ├── vector_double2_precision.hpp │ │ ├── vector_double3.hpp │ │ ├── vector_double3_precision.hpp │ │ ├── vector_double4.hpp │ │ ├── vector_double4_precision.hpp │ │ ├── vector_float1.hpp │ │ ├── vector_float1_precision.hpp │ │ ├── vector_float2.hpp │ │ ├── vector_float2_precision.hpp │ │ ├── vector_float3.hpp │ │ ├── vector_float3_precision.hpp │ │ ├── vector_float4.hpp │ │ ├── vector_float4_precision.hpp │ │ ├── vector_int1.hpp │ │ ├── vector_int1_sized.hpp │ │ ├── vector_int2.hpp │ │ ├── vector_int2_sized.hpp │ │ ├── vector_int3.hpp │ │ ├── vector_int3_sized.hpp │ │ ├── vector_int4.hpp │ │ ├── vector_int4_sized.hpp │ │ ├── vector_integer.hpp │ │ ├── vector_integer.inl │ │ ├── vector_packing.hpp │ │ ├── vector_packing.inl │ │ ├── vector_reciprocal.hpp │ │ ├── vector_reciprocal.inl │ │ ├── vector_relational.hpp │ │ ├── vector_relational.inl │ │ ├── vector_uint1.hpp │ │ ├── vector_uint1_sized.hpp │ │ ├── vector_uint2.hpp │ │ ├── vector_uint2_sized.hpp │ │ ├── vector_uint3.hpp │ │ ├── vector_uint3_sized.hpp │ │ ├── vector_uint4.hpp │ │ ├── vector_uint4_sized.hpp │ │ ├── vector_ulp.hpp │ │ └── vector_ulp.inl │ ├── fwd.hpp │ ├── geometric.hpp │ ├── glm.cppm │ ├── glm.hpp │ ├── gtc │ │ ├── bitfield.hpp │ │ ├── bitfield.inl │ │ ├── color_space.hpp │ │ ├── color_space.inl │ │ ├── constants.hpp │ │ ├── constants.inl │ │ ├── epsilon.hpp │ │ ├── epsilon.inl │ │ ├── integer.hpp │ │ ├── integer.inl │ │ ├── matrix_access.hpp │ │ ├── matrix_access.inl │ │ ├── matrix_integer.hpp │ │ ├── matrix_inverse.hpp │ │ ├── matrix_inverse.inl │ │ ├── matrix_transform.hpp │ │ ├── matrix_transform.inl │ │ ├── noise.hpp │ │ ├── noise.inl │ │ ├── packing.hpp │ │ ├── packing.inl │ │ ├── quaternion.hpp │ │ ├── quaternion.inl │ │ ├── quaternion_simd.inl │ │ ├── random.hpp │ │ ├── random.inl │ │ ├── reciprocal.hpp │ │ ├── round.hpp │ │ ├── round.inl │ │ ├── type_aligned.hpp │ │ ├── type_precision.hpp │ │ ├── type_precision.inl │ │ ├── type_ptr.hpp │ │ ├── type_ptr.inl │ │ ├── ulp.hpp │ │ ├── ulp.inl │ │ └── vec1.hpp │ ├── gtx │ │ ├── associated_min_max.hpp │ │ ├── associated_min_max.inl │ │ ├── bit.hpp │ │ ├── bit.inl │ │ ├── closest_point.hpp │ │ ├── closest_point.inl │ │ ├── color_encoding.hpp │ │ ├── color_encoding.inl │ │ ├── color_space.hpp │ │ ├── color_space.inl │ │ ├── color_space_YCoCg.hpp │ │ ├── color_space_YCoCg.inl │ │ ├── common.hpp │ │ ├── common.inl │ │ ├── compatibility.hpp │ │ ├── compatibility.inl │ │ ├── component_wise.hpp │ │ ├── component_wise.inl │ │ ├── dual_quaternion.hpp │ │ ├── dual_quaternion.inl │ │ ├── easing.hpp │ │ ├── easing.inl │ │ ├── euler_angles.hpp │ │ ├── euler_angles.inl │ │ ├── extend.hpp │ │ ├── extend.inl │ │ ├── extended_min_max.hpp │ │ ├── extended_min_max.inl │ │ ├── exterior_product.hpp │ │ ├── exterior_product.inl │ │ ├── fast_exponential.hpp │ │ ├── fast_exponential.inl │ │ ├── fast_square_root.hpp │ │ ├── fast_square_root.inl │ │ ├── fast_trigonometry.hpp │ │ ├── fast_trigonometry.inl │ │ ├── float_notmalize.inl │ │ ├── functions.hpp │ │ ├── functions.inl │ │ ├── gradient_paint.hpp │ │ ├── gradient_paint.inl │ │ ├── handed_coordinate_space.hpp │ │ ├── handed_coordinate_space.inl │ │ ├── hash.hpp │ │ ├── hash.inl │ │ ├── integer.hpp │ │ ├── integer.inl │ │ ├── intersect.hpp │ │ ├── intersect.inl │ │ ├── io.hpp │ │ ├── io.inl │ │ ├── log_base.hpp │ │ ├── log_base.inl │ │ ├── matrix_cross_product.hpp │ │ ├── matrix_cross_product.inl │ │ ├── matrix_decompose.hpp │ │ ├── matrix_decompose.inl │ │ ├── matrix_factorisation.hpp │ │ ├── matrix_factorisation.inl │ │ ├── matrix_interpolation.hpp │ │ ├── matrix_interpolation.inl │ │ ├── matrix_major_storage.hpp │ │ ├── matrix_major_storage.inl │ │ ├── matrix_operation.hpp │ │ ├── matrix_operation.inl │ │ ├── matrix_query.hpp │ │ ├── matrix_query.inl │ │ ├── matrix_transform_2d.hpp │ │ ├── matrix_transform_2d.inl │ │ ├── mixed_product.hpp │ │ ├── mixed_product.inl │ │ ├── norm.hpp │ │ ├── norm.inl │ │ ├── normal.hpp │ │ ├── normal.inl │ │ ├── normalize_dot.hpp │ │ ├── normalize_dot.inl │ │ ├── number_precision.hpp │ │ ├── optimum_pow.hpp │ │ ├── optimum_pow.inl │ │ ├── orthonormalize.hpp │ │ ├── orthonormalize.inl │ │ ├── pca.hpp │ │ ├── pca.inl │ │ ├── perpendicular.hpp │ │ ├── perpendicular.inl │ │ ├── polar_coordinates.hpp │ │ ├── polar_coordinates.inl │ │ ├── projection.hpp │ │ ├── projection.inl │ │ ├── quaternion.hpp │ │ ├── quaternion.inl │ │ ├── range.hpp │ │ ├── raw_data.hpp │ │ ├── raw_data.inl │ │ ├── rotate_normalized_axis.hpp │ │ ├── rotate_normalized_axis.inl │ │ ├── rotate_vector.hpp │ │ ├── rotate_vector.inl │ │ ├── scalar_multiplication.hpp │ │ ├── scalar_relational.hpp │ │ ├── scalar_relational.inl │ │ ├── spline.hpp │ │ ├── spline.inl │ │ ├── std_based_type.hpp │ │ ├── std_based_type.inl │ │ ├── string_cast.hpp │ │ ├── string_cast.inl │ │ ├── texture.hpp │ │ ├── texture.inl │ │ ├── transform.hpp │ │ ├── transform.inl │ │ ├── transform2.hpp │ │ ├── transform2.inl │ │ ├── type_aligned.hpp │ │ ├── type_aligned.inl │ │ ├── type_trait.hpp │ │ ├── type_trait.inl │ │ ├── vec_swizzle.hpp │ │ ├── vector_angle.hpp │ │ ├── vector_angle.inl │ │ ├── vector_query.hpp │ │ ├── vector_query.inl │ │ ├── wrap.hpp │ │ └── wrap.inl │ ├── integer.hpp │ ├── mat2x2.hpp │ ├── mat2x3.hpp │ ├── mat2x4.hpp │ ├── mat3x2.hpp │ ├── mat3x3.hpp │ ├── mat3x4.hpp │ ├── mat4x2.hpp │ ├── mat4x3.hpp │ ├── mat4x4.hpp │ ├── matrix.hpp │ ├── packing.hpp │ ├── simd │ │ ├── common.h │ │ ├── exponential.h │ │ ├── geometric.h │ │ ├── integer.h │ │ ├── matrix.h │ │ ├── neon.h │ │ ├── packing.h │ │ ├── platform.h │ │ ├── trigonometric.h │ │ └── vector_relational.h │ ├── trigonometric.hpp │ ├── vec2.hpp │ ├── vec3.hpp │ ├── vec4.hpp │ └── vector_relational.hpp ├── lua │ ├── lauxlib.h │ ├── liblua53.a.lib │ ├── lua.h │ ├── lua.hpp │ ├── lua53.dll │ ├── luaconf.h │ └── lualib.h └── sol │ ├── LICENCE │ ├── sol.hpp │ └── sol │ ├── config.hpp │ └── forward.hpp ├── premake5.exe ├── premake5.lua └── src ├── AssetStore ├── AssetManager.cpp ├── AssetManager.h ├── RendererManager.cpp └── RendererManager.h ├── Audio ├── AudioManager.cpp └── AudioManager.h ├── Events ├── CollisionEnterEvent.h ├── CollisionExitEvent.h ├── CollisionStayEvent.h ├── Event.h ├── EventBus.h ├── GameObjectCreatedEvent.h ├── GlobalEventBus.cpp ├── GlobalEventBus.h ├── KeyPressedEvent.h ├── KeyReleasedEvent.h ├── MouseButtonPressedEvent.h ├── MouseInteractedEvent.cpp ├── MouseInteractedEvent.h └── OpenLevelEvent.h ├── Game ├── Game.cpp └── Game.h ├── GameObjects ├── Component.cpp ├── Component.h ├── GameObject.cpp ├── GameObject.h └── Systems │ ├── CollisionSystem.cpp │ ├── CollisionSystem.h │ ├── RenderSystem.cpp │ └── RenderSystem.h ├── Logger ├── Logger.cpp └── Logger.h ├── LuaScripting ├── LuaScript.cpp └── LuaScript.h ├── eventbus ├── detail │ └── function_traits.hpp └── event_bus.hpp ├── imgui ├── LICENSE.txt ├── imconfig.h ├── imgui.cpp ├── imgui.h ├── imgui_demo.cpp ├── imgui_draw.cpp ├── imgui_impl_sdl2.cpp ├── imgui_impl_sdl2.h ├── imgui_impl_sdlrenderer2.cpp ├── imgui_impl_sdlrenderer2.h ├── imgui_internal.h ├── imgui_tables.cpp ├── imgui_widgets.cpp ├── imstb_rectpack.h ├── imstb_textedit.h └── imstb_truetype.h └── main.cpp /.gitignore: -------------------------------------------------------------------------------- 1 | bin 2 | bin-int 3 | .vs 4 | *.sln 5 | *.vcxproj 6 | *.user 7 | *.filters 8 | .idea 9 | cmake-build-debug 10 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.16) 2 | 3 | set(PREMAKE_BUILD_TYPES "Debug" "Release") 4 | get_property(multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) 5 | if(multi_config) 6 | set(CMAKE_CONFIGURATION_TYPES "${PREMAKE_BUILD_TYPES}" CACHE STRING "list of supported configuration types" FORCE) 7 | else() 8 | set(CMAKE_BUILD_TYPE "Debug" CACHE STRING "Build Type of the project.") 9 | set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "${PREMAKE_BUILD_TYPES}") 10 | if(NOT CMAKE_BUILD_TYPE IN_LIST PREMAKE_BUILD_TYPES) 11 | message(FATAL_ERROR 12 | "Invalid build type '${CMAKE_BUILD_TYPE}'. 13 | CMAKE_BUILD_TYPE must be any one of the possible values: 14 | ${PREMAKE_BUILD_TYPES}" 15 | ) 16 | endif() 17 | endif() 18 | 19 | set(CMAKE_MSVC_RUNTIME_LIBRARY "") 20 | set(CMAKE_C_FLAGS "") 21 | set(CMAKE_CXX_FLAGS "") 22 | set(CMAKE_C_FLAGS_DEBUG "") 23 | set(CMAKE_CXX_FLAGS_DEBUG "") 24 | set(CMAKE_C_FLAGS_RELEASE "") 25 | set(CMAKE_CXX_FLAGS_RELEASE "") 26 | 27 | project("MitoEngine2D") 28 | include(MitoEngine2D.cmake) -------------------------------------------------------------------------------- /GenerateProject.bat: -------------------------------------------------------------------------------- 1 | @echo off 2 | 3 | pushd 4 | premake5.exe --file=premake5.lua vs2022 5 | popd 6 | pause -------------------------------------------------------------------------------- /PremakeToCMake.bat: -------------------------------------------------------------------------------- 1 | premake5 cmake 2 | pause -------------------------------------------------------------------------------- /assets/fonts/arial.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/assets/fonts/arial.ttf -------------------------------------------------------------------------------- /assets/fonts/charriot.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/assets/fonts/charriot.ttf -------------------------------------------------------------------------------- /assets/images/RoundedSquare.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/assets/images/RoundedSquare.png -------------------------------------------------------------------------------- /assets/images/ball.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/assets/images/ball.png -------------------------------------------------------------------------------- /assets/images/brick.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/assets/images/brick.png -------------------------------------------------------------------------------- /assets/images/brickL.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/assets/images/brickL.png -------------------------------------------------------------------------------- /assets/images/explosion.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/assets/images/explosion.png -------------------------------------------------------------------------------- /assets/images/icon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/assets/images/icon.png -------------------------------------------------------------------------------- /assets/images/paddle.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/assets/images/paddle.png -------------------------------------------------------------------------------- /assets/levels/main.lua: -------------------------------------------------------------------------------- 1 | globals.level = 0 2 | mito.audio.play_music("menu_music.ogg") 3 | globals.bricks_destroyed = 0 4 | 5 | mito.open_level("menu.lua") -------------------------------------------------------------------------------- /assets/prefabs/brick.lua: -------------------------------------------------------------------------------- 1 | Prefab = { 2 | name = "brick", 3 | tags = { "brick"}, 4 | components = { 5 | transform = { 6 | position = { x = 0, y = 0 }, 7 | scale = 1, 8 | rotation = 0.0, 9 | }, 10 | sprite = { 11 | sprite_name = "assets/images/brick.png" 12 | }, 13 | boxcollider = { 14 | }, 15 | scripts = { "brick.lua" } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /assets/prefabs/explosionFX.lua: -------------------------------------------------------------------------------- 1 | Prefab = { 2 | name = "explosion", 3 | components = { 4 | transform = { 5 | position = { x = 0, y = 0 }, 6 | scale = 1, 7 | rotation = 0.0, 8 | }, 9 | sprite = { 10 | sprite_name = "assets/images/explosion.png", 11 | width = 64, 12 | height = 64 13 | }, 14 | animation = { 15 | frame_count = 13, 16 | frame_duration = 20, 17 | loop = false 18 | } 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /assets/scripts/GameManager.lua: -------------------------------------------------------------------------------- 1 | local rows = 1 + globals.level 2 | local columns = 1 + globals.level 3 | local localBricksDestroyed = 0 4 | local totalBricks = rows * columns 5 | 6 | function mito.event.start() 7 | local totalLength = columns * 64 8 | for i = 1, columns do 9 | for j = 1, rows do 10 | local go = mito.spawn_prefab("brick.lua") 11 | go:get_component_transform().position = mito.vec2:new( 12 | (i - 1) * 64 + (mito.window.width - totalLength) / 2, 13 | j * 32 + 50 14 | ) 15 | local r = math.random(50, 255) 16 | local g = math.random(50, 255) 17 | local b = math.random(50, 255) 18 | go:get_component_sprite().color = mito.color.new(r, g, b) 19 | end 20 | end 21 | mito.log("level:" .. tostring(globals.level)) 22 | end 23 | 24 | function mito.event.update(gameobject, deltaTime) 25 | 26 | end 27 | 28 | function mito.event.on_brick_destroyed() 29 | localBricksDestroyed = localBricksDestroyed + 1 30 | mito.log("on_brick_destroyed") 31 | if localBricksDestroyed == totalBricks then 32 | globals.level = globals.level + 1 33 | mito.open_level("game.lua") 34 | end 35 | end -------------------------------------------------------------------------------- /assets/scripts/brick.lua: -------------------------------------------------------------------------------- 1 | function mito.event.on_enable(gameobject) 2 | mito.log("on_enable on id ".. gameobject:get_id()) 3 | end 4 | 5 | function mito.event.update(gameobject,deltaTime) 6 | --mito_log(tostring(gameobject:get_id())) 7 | end -------------------------------------------------------------------------------- /assets/scripts/playbutton.lua: -------------------------------------------------------------------------------- 1 | function mito.event.on_mouse_interacted(gameobject) 2 | mito.audio.play_sound("menu_select.wav") 3 | mito.log("pressed play again button") 4 | mito.open_level("game.lua") 5 | end -------------------------------------------------------------------------------- /assets/scripts/score.lua: -------------------------------------------------------------------------------- 1 | local textcomp 2 | function mito.event.start(gameobject) 3 | mito.log("START SCORE") 4 | textcomp = gameobject:get_component_text() 5 | end 6 | 7 | function mito.event.update() 8 | textcomp.text = "Score: ".. tostring(globals.bricks_destroyed) 9 | end -------------------------------------------------------------------------------- /assets/settings/settings.lua: -------------------------------------------------------------------------------- 1 | Settings = 2 | { 3 | window = { 4 | name = "Breakout Game", 5 | fps = 999; 6 | width = 600, 7 | height = 800, 8 | icon = "./assets/images/icon.png" 9 | }, 10 | sound = { 11 | music = .2, 12 | sound = .2 13 | } 14 | } -------------------------------------------------------------------------------- /assets/sounds/ball_hit.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/assets/sounds/ball_hit.wav -------------------------------------------------------------------------------- /assets/sounds/brick_destroyed.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/assets/sounds/brick_destroyed.wav -------------------------------------------------------------------------------- /assets/sounds/game_music.ogg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/assets/sounds/game_music.ogg -------------------------------------------------------------------------------- /assets/sounds/level_up.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/assets/sounds/level_up.wav -------------------------------------------------------------------------------- /assets/sounds/menu_music.ogg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/assets/sounds/menu_music.ogg -------------------------------------------------------------------------------- /assets/sounds/menu_select.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/assets/sounds/menu_select.wav -------------------------------------------------------------------------------- /cmake/README.md: -------------------------------------------------------------------------------- 1 | [CMake](https://cmake.org/) generator for [Premake](https://github.com/premake/premake-core). 2 | 3 | # Usage 4 | 1. Put these files in a `cmake` subdirectory in one of [Premake's search paths](https://github.com/premake/premake-core/wiki/Locating-Scripts). 5 | 6 | 2. Add the line `require "cmake"` preferably to your [premake-system.lua](https://github.com/premake/premake-core/wiki/System-Scripts), or to your premake5.lua script. 7 | 8 | 3. Generate 9 | ```sh 10 | premake5 cmake 11 | ``` 12 | -------------------------------------------------------------------------------- /cmake/_manifest.lua: -------------------------------------------------------------------------------- 1 | return { 2 | "_preload.lua", 3 | "cmake.lua", 4 | "cmake_workspace.lua", 5 | "cmake_project.lua", 6 | } 7 | -------------------------------------------------------------------------------- /imgui.ini: -------------------------------------------------------------------------------- 1 | [Window][Debug##Default] 2 | Pos=25,93 3 | Size=428,314 4 | 5 | [Window][Dear ImGui Demo] 6 | Pos=804,53 7 | Size=468,497 8 | 9 | [Window][Dear ImGui Metrics/Debugger] 10 | Pos=60,60 11 | Size=339,341 12 | 13 | [Window][Example: Console] 14 | Pos=273,45 15 | Size=520,600 16 | 17 | [Window][Example: Log] 18 | Pos=34,113 19 | Size=767,400 20 | 21 | [Window][Example: Simple layout] 22 | Pos=58,60 23 | Size=500,440 24 | 25 | [Window][Example: Simple layout/left pane_AED60EF8] 26 | IsChild=1 27 | Size=150,386 28 | 29 | [Window][Dear ImGui Demo/ResizableChild_D5443E47] 30 | IsChild=1 31 | Size=499,136 32 | 33 | [Window][Dear ImGui Demo/Red_1D4E05CE] 34 | IsChild=1 35 | Size=200,100 36 | 37 | [Window][Log Window] 38 | Pos=394,220 39 | Size=479,539 40 | 41 | -------------------------------------------------------------------------------- /libs/SDL2/BUGS.txt: -------------------------------------------------------------------------------- 1 | 2 | Bugs are now managed in the SDL issue tracker, here: 3 | 4 | https://github.com/libsdl-org/SDL/issues 5 | 6 | You may report bugs there, and search to see if a given issue has already 7 | been reported, discussed, and maybe even fixed. 8 | 9 | 10 | You may also find help at the SDL forums/mailing list: 11 | 12 | https://discourse.libsdl.org/ 13 | 14 | Bug reports are welcome here, but we really appreciate if you use the issue 15 | tracker, as bugs discussed on the mailing list may be forgotten or missed. 16 | 17 | -------------------------------------------------------------------------------- /libs/SDL2/COPYING.txt: -------------------------------------------------------------------------------- 1 | 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2020 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | 21 | -------------------------------------------------------------------------------- /libs/SDL2/README-SDL.txt: -------------------------------------------------------------------------------- 1 | 2 | Please distribute this file with the SDL runtime environment: 3 | 4 | The Simple DirectMedia Layer (SDL for short) is a cross-platform library 5 | designed to make it easy to write multi-media software, such as games 6 | and emulators. 7 | 8 | The Simple DirectMedia Layer library source code is available from: 9 | https://www.libsdl.org/ 10 | 11 | This library is distributed under the terms of the zlib license: 12 | http://www.zlib.net/zlib_license.html 13 | 14 | -------------------------------------------------------------------------------- /libs/SDL2/README.txt: -------------------------------------------------------------------------------- 1 | 2 | Simple DirectMedia Layer 3 | 4 | (SDL) 5 | 6 | Version 2.0 7 | 8 | --- 9 | https://www.libsdl.org/ 10 | 11 | Simple DirectMedia Layer is a cross-platform development library designed 12 | to provide low level access to audio, keyboard, mouse, joystick, and graphics 13 | hardware via OpenGL and Direct3D. It is used by video playback software, 14 | emulators, and popular games including Valve's award winning catalog 15 | and many Humble Bundle games. 16 | 17 | More extensive documentation is available in the docs directory, starting 18 | with README.md 19 | 20 | Enjoy! 21 | Sam Lantinga (slouken@libsdl.org) 22 | -------------------------------------------------------------------------------- /libs/SDL2/docs/README-git.md: -------------------------------------------------------------------------------- 1 | git 2 | ========= 3 | 4 | The latest development version of SDL is available via git. 5 | Git allows you to get up-to-the-minute fixes and enhancements; 6 | as a developer works on a source tree, you can use "git" to mirror that 7 | source tree instead of waiting for an official release. Please look 8 | at the Git website ( https://git-scm.com/ ) for more 9 | information on using git, where you can also download software for 10 | macOS, Windows, and Unix systems. 11 | 12 | git clone https://github.com/libsdl-org/SDL 13 | 14 | If you are building SDL via configure, you will need to run autogen.sh 15 | before running configure. 16 | 17 | There is a web interface to the Git repository at: 18 | http://github.com/libsdl-org/SDL/ 19 | 20 | -------------------------------------------------------------------------------- /libs/SDL2/docs/README-hg.md: -------------------------------------------------------------------------------- 1 | We are no longer hosted in Mercurial. Please see README-git.md for details. 2 | 3 | Thanks! 4 | 5 | -------------------------------------------------------------------------------- /libs/SDL2/docs/README-pandora.md: -------------------------------------------------------------------------------- 1 | Pandora 2 | ===================================================================== 3 | 4 | ( http://openpandora.org/ ) 5 | - A pandora specific video driver was written to allow SDL 2.0 with OpenGL ES 6 | support to work on the pandora under the framebuffer. This driver do not have 7 | input support for now, so if you use it you will have to add your own control code. 8 | The video driver name is "pandora" so if you have problem running it from 9 | the framebuffer, try to set the following variable before starting your application : 10 | "export SDL_VIDEODRIVER=pandora" 11 | 12 | - OpenGL ES support was added to the x11 driver, so it's working like the normal 13 | x11 driver one with OpenGLX support, with SDL input event's etc.. 14 | 15 | 16 | David Carré (Cpasjuste) 17 | cpasjuste@gmail.com 18 | -------------------------------------------------------------------------------- /libs/SDL2/docs/README-platforms.md: -------------------------------------------------------------------------------- 1 | Platforms 2 | ========= 3 | 4 | We maintain the list of supported platforms on our wiki now, and how to 5 | build and install SDL for those platforms: 6 | 7 | https://wiki.libsdl.org/Installation 8 | 9 | -------------------------------------------------------------------------------- /libs/SDL2/docs/README-psp.md: -------------------------------------------------------------------------------- 1 | PSP 2 | ====== 3 | SDL2 port for the Sony PSP contributed by: 4 | - Captian Lex 5 | - Francisco Javier Trujillo Mata 6 | - Wouter Wijsman 7 | 8 | 9 | Credit to 10 | Marcus R.Brown,Jim Paris,Matthew H for the original SDL 1.2 for PSP 11 | Geecko for his PSP GU lib "Glib2d" 12 | 13 | ## Building 14 | To build SDL2 library for the PSP, make sure you have the latest PSPDev status and run: 15 | ```bash 16 | cmake -S. -Bbuild -DCMAKE_BUILD_TYPE=Release -DCMAKE_TOOLCHAIN_FILE=$PSPDEV/psp/share/pspdev.cmake 17 | cmake --build build 18 | cmake --install build 19 | ``` 20 | 21 | 22 | ## Getting PSP Dev 23 | [Installing PSP Dev](https://github.com/pspdev/pspdev) 24 | 25 | ## Running on PPSSPP Emulator 26 | [PPSSPP](https://github.com/hrydgard/ppsspp) 27 | 28 | [Build Instructions](https://github.com/hrydgard/ppsspp/wiki/Build-instructions) 29 | 30 | 31 | ## Compiling a HelloWorld 32 | [PSP Hello World](https://psp-dev.org/doku.php?id=tutorial:hello_world) 33 | 34 | ## To Do 35 | - PSP Screen Keyboard 36 | - Dialogs 37 | -------------------------------------------------------------------------------- /libs/SDL2/docs/README-wince.md: -------------------------------------------------------------------------------- 1 | WinCE 2 | ===== 3 | 4 | Windows CE is no longer supported by SDL. 5 | 6 | We have left the CE support in SDL 1.2 for those that must have it, and we 7 | have support for Windows Phone 8 and WinRT in SDL2, as of SDL 2.0.3. 8 | 9 | --ryan. 10 | 11 | -------------------------------------------------------------------------------- /libs/SDL2/docs/release_checklist.md: -------------------------------------------------------------------------------- 1 | # Release checklist 2 | 3 | When changing the version, run `build-scripts/update-version.sh X Y Z`, 4 | where `X Y Z` are the major version, minor version, and patch level. So 5 | `2 28 1` means "change the version to 2.28.1". This script does much of the 6 | mechanical work. 7 | 8 | 9 | ## New feature release 10 | 11 | * Update `WhatsNew.txt` 12 | 13 | * Bump version number to 2.EVEN.0: 14 | 15 | * `./build-scripts/update-version.sh 2 EVEN 0` 16 | 17 | * Do the release 18 | 19 | * Update the website file include/header.inc.php to reflect the new version 20 | 21 | ## New bugfix release 22 | 23 | * Check that no new API/ABI was added 24 | 25 | * If it was, do a new feature release (see above) instead 26 | 27 | * Bump version number from 2.Y.Z to 2.Y.(Z+1) (Y is even) 28 | 29 | * `./build-scripts/update-version.sh 2 Y Z+1` 30 | 31 | * Do the release 32 | 33 | * Update the website file include/header.inc.php to reflect the new version 34 | 35 | ## After a feature release 36 | 37 | * Create a branch like `release-2.24.x` 38 | 39 | * Bump version number to 2.ODD.0 for next development branch 40 | 41 | * `./build-scripts/update-version.sh 2 ODD 0` 42 | 43 | ## New development prerelease 44 | 45 | * Bump version number from 2.Y.Z to 2.Y.(Z+1) (Y is odd) 46 | 47 | * `./build-scripts/update-version.sh 2 Y Z+1` 48 | 49 | * Do the release 50 | -------------------------------------------------------------------------------- /libs/SDL2/include/SDL_name.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2024 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | #ifndef SDLname_h_ 23 | #define SDLname_h_ 24 | 25 | #if defined(__STDC__) || defined(__cplusplus) 26 | #define NeedFunctionPrototypes 1 27 | #endif 28 | 29 | #define SDL_NAME(X) SDL_##X 30 | 31 | #endif /* SDLname_h_ */ 32 | 33 | /* vi: set ts=4 sw=4 expandtab: */ 34 | -------------------------------------------------------------------------------- /libs/SDL2/include/SDL_opengles.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2024 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_opengles.h 24 | * 25 | * This is a simple file to encapsulate the OpenGL ES 1.X API headers. 26 | */ 27 | #include "SDL_config.h" 28 | 29 | #ifdef __IPHONEOS__ 30 | #include 31 | #include 32 | #else 33 | #include 34 | #include 35 | #endif 36 | 37 | #ifndef APIENTRY 38 | #define APIENTRY 39 | #endif 40 | -------------------------------------------------------------------------------- /libs/SDL2/include/SDL_opengles2_gl2platform.h: -------------------------------------------------------------------------------- 1 | #ifndef __gl2platform_h_ 2 | #define __gl2platform_h_ 3 | 4 | /* 5 | ** Copyright 2017-2020 The Khronos Group Inc. 6 | ** SPDX-License-Identifier: Apache-2.0 7 | */ 8 | 9 | /* Platform-specific types and definitions for OpenGL ES 2.X gl2.h 10 | * 11 | * Adopters may modify khrplatform.h and this file to suit their platform. 12 | * Please contribute modifications back to Khronos as pull requests on the 13 | * public github repository: 14 | * https://github.com/KhronosGroup/OpenGL-Registry 15 | */ 16 | 17 | /*#include */ 18 | 19 | #ifndef GL_APICALL 20 | #define GL_APICALL KHRONOS_APICALL 21 | #endif 22 | 23 | #ifndef GL_APIENTRY 24 | #define GL_APIENTRY KHRONOS_APIENTRY 25 | #endif 26 | 27 | #endif /* __gl2platform_h_ */ 28 | -------------------------------------------------------------------------------- /libs/SDL2/include/SDL_revision.h: -------------------------------------------------------------------------------- 1 | /* Generated by updaterev.sh, do not edit */ 2 | #ifdef SDL_VENDOR_INFO 3 | #define SDL_REVISION "SDL-release-2.30.3-0-gfb1497566 (" SDL_VENDOR_INFO ")" 4 | #else 5 | #define SDL_REVISION "SDL-release-2.30.3-0-gfb1497566" 6 | #endif 7 | #define SDL_REVISION_NUMBER 0 8 | -------------------------------------------------------------------------------- /libs/SDL2/include/SDL_types.h: -------------------------------------------------------------------------------- 1 | /* 2 | Simple DirectMedia Layer 3 | Copyright (C) 1997-2024 Sam Lantinga 4 | 5 | This software is provided 'as-is', without any express or implied 6 | warranty. In no event will the authors be held liable for any damages 7 | arising from the use of this software. 8 | 9 | Permission is granted to anyone to use this software for any purpose, 10 | including commercial applications, and to alter it and redistribute it 11 | freely, subject to the following restrictions: 12 | 13 | 1. The origin of this software must not be misrepresented; you must not 14 | claim that you wrote the original software. If you use this software 15 | in a product, an acknowledgment in the product documentation would be 16 | appreciated but is not required. 17 | 2. Altered source versions must be plainly marked as such, and must not be 18 | misrepresented as being the original software. 19 | 3. This notice may not be removed or altered from any source distribution. 20 | */ 21 | 22 | /** 23 | * \file SDL_types.h 24 | * 25 | * \deprecated 26 | */ 27 | 28 | /* DEPRECATED */ 29 | #include "SDL_stdinc.h" 30 | -------------------------------------------------------------------------------- /libs/SDL2/lib/x64/SDL2.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2/lib/x64/SDL2.dll -------------------------------------------------------------------------------- /libs/SDL2/lib/x64/SDL2.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2/lib/x64/SDL2.lib -------------------------------------------------------------------------------- /libs/SDL2/lib/x64/SDL2main.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2/lib/x64/SDL2main.lib -------------------------------------------------------------------------------- /libs/SDL2/lib/x64/SDL2test.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2/lib/x64/SDL2test.lib -------------------------------------------------------------------------------- /libs/SDL2/lib/x86/SDL2.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2/lib/x86/SDL2.dll -------------------------------------------------------------------------------- /libs/SDL2/lib/x86/SDL2.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2/lib/x86/SDL2.lib -------------------------------------------------------------------------------- /libs/SDL2/lib/x86/SDL2main.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2/lib/x86/SDL2main.lib -------------------------------------------------------------------------------- /libs/SDL2/lib/x86/SDL2test.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2/lib/x86/SDL2test.lib -------------------------------------------------------------------------------- /libs/SDL2_image/LICENSE.txt: -------------------------------------------------------------------------------- 1 | Copyright (C) 1997-2024 Sam Lantinga 2 | 3 | This software is provided 'as-is', without any express or implied 4 | warranty. In no event will the authors be held liable for any damages 5 | arising from the use of this software. 6 | 7 | Permission is granted to anyone to use this software for any purpose, 8 | including commercial applications, and to alter it and redistribute it 9 | freely, subject to the following restrictions: 10 | 11 | 1. The origin of this software must not be misrepresented; you must not 12 | claim that you wrote the original software. If you use this software 13 | in a product, an acknowledgment in the product documentation would be 14 | appreciated but is not required. 15 | 2. Altered source versions must be plainly marked as such, and must not be 16 | misrepresented as being the original software. 17 | 3. This notice may not be removed or altered from any source distribution. 18 | -------------------------------------------------------------------------------- /libs/SDL2_image/lib/x64/SDL2_image.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_image/lib/x64/SDL2_image.dll -------------------------------------------------------------------------------- /libs/SDL2_image/lib/x64/SDL2_image.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_image/lib/x64/SDL2_image.lib -------------------------------------------------------------------------------- /libs/SDL2_image/lib/x64/optional/LICENSE.dav1d.txt: -------------------------------------------------------------------------------- 1 | Copyright © 2018-2019, VideoLAN and dav1d authors 2 | All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without 5 | modification, are permitted provided that the following conditions are met: 6 | 7 | 1. Redistributions of source code must retain the above copyright notice, this 8 | list of conditions and the following disclaimer. 9 | 10 | 2. Redistributions in binary form must reproduce the above copyright notice, 11 | this list of conditions and the following disclaimer in the documentation 12 | and/or other materials provided with the distribution. 13 | 14 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 15 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 16 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 17 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR 18 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 19 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 20 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 21 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 22 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 23 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 24 | -------------------------------------------------------------------------------- /libs/SDL2_image/lib/x64/optional/LICENSE.tiff.txt: -------------------------------------------------------------------------------- 1 | Copyright (c) 1988-1997 Sam Leffler 2 | Copyright (c) 1991-1997 Silicon Graphics, Inc. 3 | 4 | Permission to use, copy, modify, distribute, and sell this software and 5 | its documentation for any purpose is hereby granted without fee, provided 6 | that (i) the above copyright notices and this permission notice appear in 7 | all copies of the software and related documentation, and (ii) the names of 8 | Sam Leffler and Silicon Graphics may not be used in any advertising or 9 | publicity relating to the software without the specific, prior written 10 | permission of Sam Leffler and Silicon Graphics. 11 | 12 | THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 13 | EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 14 | WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 15 | 16 | IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR 17 | ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, 18 | OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, 19 | WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 20 | LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 21 | OF THIS SOFTWARE. 22 | -------------------------------------------------------------------------------- /libs/SDL2_image/lib/x64/optional/libavif-16.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_image/lib/x64/optional/libavif-16.dll -------------------------------------------------------------------------------- /libs/SDL2_image/lib/x64/optional/libtiff-5.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_image/lib/x64/optional/libtiff-5.dll -------------------------------------------------------------------------------- /libs/SDL2_image/lib/x64/optional/libwebp-7.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_image/lib/x64/optional/libwebp-7.dll -------------------------------------------------------------------------------- /libs/SDL2_image/lib/x64/optional/libwebpdemux-2.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_image/lib/x64/optional/libwebpdemux-2.dll -------------------------------------------------------------------------------- /libs/SDL2_image/lib/x86/SDL2_image.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_image/lib/x86/SDL2_image.dll -------------------------------------------------------------------------------- /libs/SDL2_image/lib/x86/SDL2_image.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_image/lib/x86/SDL2_image.lib -------------------------------------------------------------------------------- /libs/SDL2_image/lib/x86/optional/LICENSE.dav1d.txt: -------------------------------------------------------------------------------- 1 | Copyright © 2018-2019, VideoLAN and dav1d authors 2 | All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without 5 | modification, are permitted provided that the following conditions are met: 6 | 7 | 1. Redistributions of source code must retain the above copyright notice, this 8 | list of conditions and the following disclaimer. 9 | 10 | 2. Redistributions in binary form must reproduce the above copyright notice, 11 | this list of conditions and the following disclaimer in the documentation 12 | and/or other materials provided with the distribution. 13 | 14 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 15 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 16 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 17 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR 18 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 19 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 20 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 21 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 22 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 23 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 24 | -------------------------------------------------------------------------------- /libs/SDL2_image/lib/x86/optional/LICENSE.tiff.txt: -------------------------------------------------------------------------------- 1 | Copyright (c) 1988-1997 Sam Leffler 2 | Copyright (c) 1991-1997 Silicon Graphics, Inc. 3 | 4 | Permission to use, copy, modify, distribute, and sell this software and 5 | its documentation for any purpose is hereby granted without fee, provided 6 | that (i) the above copyright notices and this permission notice appear in 7 | all copies of the software and related documentation, and (ii) the names of 8 | Sam Leffler and Silicon Graphics may not be used in any advertising or 9 | publicity relating to the software without the specific, prior written 10 | permission of Sam Leffler and Silicon Graphics. 11 | 12 | THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 13 | EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 14 | WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 15 | 16 | IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR 17 | ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, 18 | OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, 19 | WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 20 | LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 21 | OF THIS SOFTWARE. 22 | -------------------------------------------------------------------------------- /libs/SDL2_image/lib/x86/optional/libavif-16.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_image/lib/x86/optional/libavif-16.dll -------------------------------------------------------------------------------- /libs/SDL2_image/lib/x86/optional/libtiff-5.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_image/lib/x86/optional/libtiff-5.dll -------------------------------------------------------------------------------- /libs/SDL2_image/lib/x86/optional/libwebp-7.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_image/lib/x86/optional/libwebp-7.dll -------------------------------------------------------------------------------- /libs/SDL2_image/lib/x86/optional/libwebpdemux-2.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_image/lib/x86/optional/libwebpdemux-2.dll -------------------------------------------------------------------------------- /libs/SDL2_mixer/LICENSE.txt: -------------------------------------------------------------------------------- 1 | Copyright (C) 1997-2024 Sam Lantinga 2 | 3 | This software is provided 'as-is', without any express or implied 4 | warranty. In no event will the authors be held liable for any damages 5 | arising from the use of this software. 6 | 7 | Permission is granted to anyone to use this software for any purpose, 8 | including commercial applications, and to alter it and redistribute it 9 | freely, subject to the following restrictions: 10 | 11 | 1. The origin of this software must not be misrepresented; you must not 12 | claim that you wrote the original software. If you use this software 13 | in a product, an acknowledgment in the product documentation would be 14 | appreciated but is not required. 15 | 2. Altered source versions must be plainly marked as such, and must not be 16 | misrepresented as being the original software. 17 | 3. This notice may not be removed or altered from any source distribution. 18 | -------------------------------------------------------------------------------- /libs/SDL2_mixer/lib/x64/SDL2_mixer.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_mixer/lib/x64/SDL2_mixer.dll -------------------------------------------------------------------------------- /libs/SDL2_mixer/lib/x64/SDL2_mixer.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_mixer/lib/x64/SDL2_mixer.lib -------------------------------------------------------------------------------- /libs/SDL2_mixer/lib/x64/optional/LICENSE.xmp.txt: -------------------------------------------------------------------------------- 1 | Extended Module Player 2 | Copyright (C) 1996-2023 Claudio Matsuoka and Hipolito Carraro Jr 3 | 4 | Permission is hereby granted, free of charge, to any person obtaining a 5 | copy of this software and associated documentation files (the "Software"), 6 | to deal in the Software without restriction, including without limitation 7 | the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 | and/or sell copies of the Software, and to permit persons to whom the 9 | Software is furnished to do so, subject to the following conditions: 10 | 11 | The above copyright notice and this permission notice shall be included in 12 | all copies or substantial portions of the Software. 13 | 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 17 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 18 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 19 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 20 | THE SOFTWARE. 21 | -------------------------------------------------------------------------------- /libs/SDL2_mixer/lib/x64/optional/libgme.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_mixer/lib/x64/optional/libgme.dll -------------------------------------------------------------------------------- /libs/SDL2_mixer/lib/x64/optional/libogg-0.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_mixer/lib/x64/optional/libogg-0.dll -------------------------------------------------------------------------------- /libs/SDL2_mixer/lib/x64/optional/libopus-0.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_mixer/lib/x64/optional/libopus-0.dll -------------------------------------------------------------------------------- /libs/SDL2_mixer/lib/x64/optional/libopusfile-0.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_mixer/lib/x64/optional/libopusfile-0.dll -------------------------------------------------------------------------------- /libs/SDL2_mixer/lib/x64/optional/libwavpack-1.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_mixer/lib/x64/optional/libwavpack-1.dll -------------------------------------------------------------------------------- /libs/SDL2_mixer/lib/x64/optional/libxmp.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_mixer/lib/x64/optional/libxmp.dll -------------------------------------------------------------------------------- /libs/SDL2_mixer/lib/x86/SDL2_mixer.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_mixer/lib/x86/SDL2_mixer.dll -------------------------------------------------------------------------------- /libs/SDL2_mixer/lib/x86/SDL2_mixer.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_mixer/lib/x86/SDL2_mixer.lib -------------------------------------------------------------------------------- /libs/SDL2_mixer/lib/x86/optional/LICENSE.xmp.txt: -------------------------------------------------------------------------------- 1 | Extended Module Player 2 | Copyright (C) 1996-2023 Claudio Matsuoka and Hipolito Carraro Jr 3 | 4 | Permission is hereby granted, free of charge, to any person obtaining a 5 | copy of this software and associated documentation files (the "Software"), 6 | to deal in the Software without restriction, including without limitation 7 | the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 | and/or sell copies of the Software, and to permit persons to whom the 9 | Software is furnished to do so, subject to the following conditions: 10 | 11 | The above copyright notice and this permission notice shall be included in 12 | all copies or substantial portions of the Software. 13 | 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 17 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 18 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 19 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 20 | THE SOFTWARE. 21 | -------------------------------------------------------------------------------- /libs/SDL2_mixer/lib/x86/optional/libgme.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_mixer/lib/x86/optional/libgme.dll -------------------------------------------------------------------------------- /libs/SDL2_mixer/lib/x86/optional/libogg-0.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_mixer/lib/x86/optional/libogg-0.dll -------------------------------------------------------------------------------- /libs/SDL2_mixer/lib/x86/optional/libopus-0.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_mixer/lib/x86/optional/libopus-0.dll -------------------------------------------------------------------------------- /libs/SDL2_mixer/lib/x86/optional/libopusfile-0.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_mixer/lib/x86/optional/libopusfile-0.dll -------------------------------------------------------------------------------- /libs/SDL2_mixer/lib/x86/optional/libwavpack-1.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_mixer/lib/x86/optional/libwavpack-1.dll -------------------------------------------------------------------------------- /libs/SDL2_mixer/lib/x86/optional/libxmp.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_mixer/lib/x86/optional/libxmp.dll -------------------------------------------------------------------------------- /libs/SDL2_ttf/LICENSE.txt: -------------------------------------------------------------------------------- 1 | Copyright (C) 1997-2024 Sam Lantinga 2 | 3 | This software is provided 'as-is', without any express or implied 4 | warranty. In no event will the authors be held liable for any damages 5 | arising from the use of this software. 6 | 7 | Permission is granted to anyone to use this software for any purpose, 8 | including commercial applications, and to alter it and redistribute it 9 | freely, subject to the following restrictions: 10 | 11 | 1. The origin of this software must not be misrepresented; you must not 12 | claim that you wrote the original software. If you use this software 13 | in a product, an acknowledgment in the product documentation would be 14 | appreciated but is not required. 15 | 2. Altered source versions must be plainly marked as such, and must not be 16 | misrepresented as being the original software. 17 | 3. This notice may not be removed or altered from any source distribution. 18 | -------------------------------------------------------------------------------- /libs/SDL2_ttf/README.txt: -------------------------------------------------------------------------------- 1 | 2 | SDL_ttf 2.0 3 | 4 | The latest version of this library is available from GitHub: 5 | https://github.com/libsdl-org/SDL_ttf/releases 6 | 7 | This library is a wrapper around the FreeType and Harfbuzz libraries, allowing you to use TrueType fonts to render text in SDL applications. 8 | 9 | See the header file SDL_ttf.h and the example showfont.c for documentation on this library. This documentation is also available online at https://wiki.libsdl.org/SDL_ttf 10 | 11 | Be careful when including fonts with your application, as many of them are copyrighted. The Microsoft fonts, for example, are not freely redistributable and even the free "web" fonts they provide are only redistributable in their special executable installer form (May 1998). There are plenty of freeware and shareware fonts available on the Internet though, and may suit your purposes. 12 | 13 | This library is under the zlib license, see the file "LICENSE.txt" for details. 14 | 15 | Portions of this software are copyright © 2013 The FreeType Project (www.freetype.org). All rights reserved. 16 | -------------------------------------------------------------------------------- /libs/SDL2_ttf/lib/x64/SDL2_ttf.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_ttf/lib/x64/SDL2_ttf.dll -------------------------------------------------------------------------------- /libs/SDL2_ttf/lib/x64/SDL2_ttf.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_ttf/lib/x64/SDL2_ttf.lib -------------------------------------------------------------------------------- /libs/SDL2_ttf/lib/x86/SDL2_ttf.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_ttf/lib/x86/SDL2_ttf.dll -------------------------------------------------------------------------------- /libs/SDL2_ttf/lib/x86/SDL2_ttf.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/SDL2_ttf/lib/x86/SDL2_ttf.lib -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/detail/compute_common.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "setup.hpp" 4 | #include 5 | 6 | namespace glm{ 7 | namespace detail 8 | { 9 | template 10 | struct compute_abs 11 | {}; 12 | 13 | template 14 | struct compute_abs 15 | { 16 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genFIType call(genFIType x) 17 | { 18 | GLM_STATIC_ASSERT( 19 | std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT || std::numeric_limits::is_signed, 20 | "'abs' only accept floating-point and integer scalar or vector inputs"); 21 | 22 | return x >= genFIType(0) ? x : -x; 23 | // TODO, perf comp with: *(((int *) &x) + 1) &= 0x7fffffff; 24 | } 25 | }; 26 | 27 | #if (GLM_COMPILER & GLM_COMPILER_CUDA) || (GLM_COMPILER & GLM_COMPILER_HIP) 28 | template<> 29 | struct compute_abs 30 | { 31 | GLM_FUNC_QUALIFIER static float call(float x) 32 | { 33 | return fabsf(x); 34 | } 35 | }; 36 | #endif 37 | 38 | template 39 | struct compute_abs 40 | { 41 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR static genFIType call(genFIType x) 42 | { 43 | GLM_STATIC_ASSERT( 44 | (!std::numeric_limits::is_signed && std::numeric_limits::is_integer), 45 | "'abs' only accept floating-point and integer scalar or vector inputs"); 46 | return x; 47 | } 48 | }; 49 | }//namespace detail 50 | }//namespace glm 51 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/detail/func_packing_simd.inl: -------------------------------------------------------------------------------- 1 | namespace glm{ 2 | namespace detail 3 | { 4 | 5 | }//namespace detail 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /libs/glm/detail/func_trigonometric_simd.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/glm/detail/func_trigonometric_simd.inl -------------------------------------------------------------------------------- /libs/glm/detail/func_vector_relational_simd.inl: -------------------------------------------------------------------------------- 1 | namespace glm{ 2 | namespace detail 3 | { 4 | 5 | }//namespace detail 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/detail/type_mat4x4_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | 3 | namespace glm 4 | { 5 | 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /libs/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_common 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 | template 34 | GLM_FUNC_DECL GLM_CONSTEXPR mat abs(mat const& x); 35 | 36 | /// @} 37 | }//namespace glm 38 | 39 | #include "matrix_common.inl" 40 | -------------------------------------------------------------------------------- /libs/glm/ext/matrix_common.inl: -------------------------------------------------------------------------------- 1 | #include "../matrix.hpp" 2 | 3 | #include "_matrix_vectorize.hpp" 4 | 5 | namespace glm 6 | { 7 | template 8 | GLM_FUNC_QUALIFIER mat mix(mat const& x, mat const& y, U a) 9 | { 10 | return mat(x) * (static_cast(1) - a) + mat(y) * a; 11 | } 12 | 13 | template 14 | GLM_FUNC_QUALIFIER mat mix(mat const& x, mat const& y, mat const& a) 15 | { 16 | return matrixCompMult(mat(x), static_cast(1) - a) + matrixCompMult(mat(y), a); 17 | } 18 | 19 | template 20 | struct compute_abs_matrix 21 | { 22 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR static mat call(mat const& x) 23 | { 24 | return detail::matrix_functor_1::call(abs, x); 25 | } 26 | }; 27 | 28 | template 29 | GLM_FUNC_DECL GLM_CONSTEXPR mat abs(mat const& x) 30 | { 31 | return compute_abs_matrix::value>::call(x); 32 | } 33 | 34 | }//namespace glm 35 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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_matrix 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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/matrix_int2x3_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int2x3_sized 2 | /// @file glm/ext/matrix_int2x3_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x3_sized GLM_EXT_matrix_int2x3_sized 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 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_int2x3_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_int2x3_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer 2x3 matrix. 29 | /// 30 | /// @see ext_matrix_int2x3_sized 31 | typedef mat<2, 3, int8, defaultp> i8mat2x3; 32 | 33 | /// 16 bit signed integer 2x3 matrix. 34 | /// 35 | /// @see ext_matrix_int2x3_sized 36 | typedef mat<2, 3, int16, defaultp> i16mat2x3; 37 | 38 | /// 32 bit signed integer 2x3 matrix. 39 | /// 40 | /// @see ext_matrix_int2x3_sized 41 | typedef mat<2, 3, int32, defaultp> i32mat2x3; 42 | 43 | /// 64 bit signed integer 2x3 matrix. 44 | /// 45 | /// @see ext_matrix_int2x3_sized 46 | typedef mat<2, 3, int64, defaultp> i64mat2x3; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/matrix_int2x4_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int2x4_sized 2 | /// @file glm/ext/matrix_int2x4_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int2x4_sized GLM_EXT_matrix_int2x4_sized 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 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_int2x4_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_int2x4_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer 2x4 matrix. 29 | /// 30 | /// @see ext_matrix_int2x4_sized 31 | typedef mat<2, 4, int8, defaultp> i8mat2x4; 32 | 33 | /// 16 bit signed integer 2x4 matrix. 34 | /// 35 | /// @see ext_matrix_int2x4_sized 36 | typedef mat<2, 4, int16, defaultp> i16mat2x4; 37 | 38 | /// 32 bit signed integer 2x4 matrix. 39 | /// 40 | /// @see ext_matrix_int2x4_sized 41 | typedef mat<2, 4, int32, defaultp> i32mat2x4; 42 | 43 | /// 64 bit signed integer 2x4 matrix. 44 | /// 45 | /// @see ext_matrix_int2x4_sized 46 | typedef mat<2, 4, int64, defaultp> i64mat2x4; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/matrix_int3x2_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int3x2_sized 2 | /// @file glm/ext/matrix_int3x2_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x2_sized GLM_EXT_matrix_int3x2_sized 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 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_int3x2_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_int3x2_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer 3x2 matrix. 29 | /// 30 | /// @see ext_matrix_int3x2_sized 31 | typedef mat<3, 2, int8, defaultp> i8mat3x2; 32 | 33 | /// 16 bit signed integer 3x2 matrix. 34 | /// 35 | /// @see ext_matrix_int3x2_sized 36 | typedef mat<3, 2, int16, defaultp> i16mat3x2; 37 | 38 | /// 32 bit signed integer 3x2 matrix. 39 | /// 40 | /// @see ext_matrix_int3x2_sized 41 | typedef mat<3, 2, int32, defaultp> i32mat3x2; 42 | 43 | /// 64 bit signed integer 3x2 matrix. 44 | /// 45 | /// @see ext_matrix_int3x2_sized 46 | typedef mat<3, 2, int64, defaultp> i64mat3x2; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/matrix_int3x4_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int3x4_sized 2 | /// @file glm/ext/matrix_int3x2_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int3x4_sized GLM_EXT_matrix_int3x4_sized 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 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_int3x4_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_int3x4_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer 3x4 matrix. 29 | /// 30 | /// @see ext_matrix_int3x4_sized 31 | typedef mat<3, 4, int8, defaultp> i8mat3x4; 32 | 33 | /// 16 bit signed integer 3x4 matrix. 34 | /// 35 | /// @see ext_matrix_int3x4_sized 36 | typedef mat<3, 4, int16, defaultp> i16mat3x4; 37 | 38 | /// 32 bit signed integer 3x4 matrix. 39 | /// 40 | /// @see ext_matrix_int3x4_sized 41 | typedef mat<3, 4, int32, defaultp> i32mat3x4; 42 | 43 | /// 64 bit signed integer 3x4 matrix. 44 | /// 45 | /// @see ext_matrix_int3x4_sized 46 | typedef mat<3, 4, int64, defaultp> i64mat3x4; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/matrix_int4x2_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int4x2_sized 2 | /// @file glm/ext/matrix_int4x2_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int4x2_sized GLM_EXT_matrix_int4x2_sized 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 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_int4x2_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_int4x2_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer 4x2 matrix. 29 | /// 30 | /// @see ext_matrix_int4x2_sized 31 | typedef mat<4, 2, int8, defaultp> i8mat4x2; 32 | 33 | /// 16 bit signed integer 4x2 matrix. 34 | /// 35 | /// @see ext_matrix_int4x2_sized 36 | typedef mat<4, 2, int16, defaultp> i16mat4x2; 37 | 38 | /// 32 bit signed integer 4x2 matrix. 39 | /// 40 | /// @see ext_matrix_int4x2_sized 41 | typedef mat<4, 2, int32, defaultp> i32mat4x2; 42 | 43 | /// 64 bit signed integer 4x2 matrix. 44 | /// 45 | /// @see ext_matrix_int4x2_sized 46 | typedef mat<4, 2, int64, defaultp> i64mat4x2; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/matrix_int4x3_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_int4x3_sized 2 | /// @file glm/ext/matrix_int4x3_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_int4x3_sized GLM_EXT_matrix_int4x3_sized 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 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_int4x3_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_int4x3_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer 4x3 matrix. 29 | /// 30 | /// @see ext_matrix_int4x3_sized 31 | typedef mat<4, 3, int8, defaultp> i8mat4x3; 32 | 33 | /// 16 bit signed integer 4x3 matrix. 34 | /// 35 | /// @see ext_matrix_int4x3_sized 36 | typedef mat<4, 3, int16, defaultp> i16mat4x3; 37 | 38 | /// 32 bit signed integer 4x3 matrix. 39 | /// 40 | /// @see ext_matrix_int4x3_sized 41 | typedef mat<4, 3, int32, defaultp> i32mat4x3; 42 | 43 | /// 64 bit signed integer 4x3 matrix. 44 | /// 45 | /// @see ext_matrix_int4x3_sized 46 | typedef mat<4, 3, int64, defaultp> i64mat4x3; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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_uint2x3 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 | -------------------------------------------------------------------------------- /libs/glm/ext/matrix_uint2x3_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint2x3_sized 2 | /// @file glm/ext/matrix_uint2x3_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint2x3_sized GLM_EXT_matrix_uint2x3_sized 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 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_uint2x3_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_uint2x3_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer 2x3 matrix. 29 | /// 30 | /// @see ext_matrix_uint2x3_sized 31 | typedef mat<2, 3, uint8, defaultp> u8mat2x3; 32 | 33 | /// 16 bit unsigned integer 2x3 matrix. 34 | /// 35 | /// @see ext_matrix_uint2x3_sized 36 | typedef mat<2, 3, uint16, defaultp> u16mat2x3; 37 | 38 | /// 32 bit unsigned integer 2x3 matrix. 39 | /// 40 | /// @see ext_matrix_uint2x3_sized 41 | typedef mat<2, 3, uint32, defaultp> u32mat2x3; 42 | 43 | /// 64 bit unsigned integer 2x3 matrix. 44 | /// 45 | /// @see ext_matrix_uint2x3_sized 46 | typedef mat<2, 3, uint64, defaultp> u64mat2x3; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/matrix_uint2x4_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint2x4_sized 2 | /// @file glm/ext/matrix_uint2x4_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint2x4_sized GLM_EXT_matrix_uint2x4_sized 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 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_uint2x4_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_uint2x4_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer 2x4 matrix. 29 | /// 30 | /// @see ext_matrix_uint2x4_sized 31 | typedef mat<2, 4, uint8, defaultp> u8mat2x4; 32 | 33 | /// 16 bit unsigned integer 2x4 matrix. 34 | /// 35 | /// @see ext_matrix_uint2x4_sized 36 | typedef mat<2, 4, uint16, defaultp> u16mat2x4; 37 | 38 | /// 32 bit unsigned integer 2x4 matrix. 39 | /// 40 | /// @see ext_matrix_uint2x4_sized 41 | typedef mat<2, 4, uint32, defaultp> u32mat2x4; 42 | 43 | /// 64 bit unsigned integer 2x4 matrix. 44 | /// 45 | /// @see ext_matrix_uint2x4_sized 46 | typedef mat<2, 4, uint64, defaultp> u64mat2x4; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /libs/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_uint3x2 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 | -------------------------------------------------------------------------------- /libs/glm/ext/matrix_uint3x2_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint3x2_sized 2 | /// @file glm/ext/matrix_uint3x2_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint3x2_sized GLM_EXT_matrix_uint3x2_sized 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 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_uint3x2_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_uint3x2_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer 3x2 matrix. 29 | /// 30 | /// @see ext_matrix_uint3x2_sized 31 | typedef mat<3, 2, uint8, defaultp> u8mat3x2; 32 | 33 | /// 16 bit signed integer 3x2 matrix. 34 | /// 35 | /// @see ext_matrix_uint3x2_sized 36 | typedef mat<3, 2, uint16, defaultp> u16mat3x2; 37 | 38 | /// 32 bit signed integer 3x2 matrix. 39 | /// 40 | /// @see ext_matrix_uint3x2_sized 41 | typedef mat<3, 2, uint32, defaultp> u32mat3x2; 42 | 43 | /// 64 bit signed integer 3x2 matrix. 44 | /// 45 | /// @see ext_matrix_uint3x2_sized 46 | typedef mat<3, 2, uint64, defaultp> u64mat3x2; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/matrix_uint3x4_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint3x4_sized 2 | /// @file glm/ext/matrix_uint3x2_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint3x4_sized GLM_EXT_matrix_uint3x4_sized 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 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_uint3x4_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_uint3x4_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer 3x4 matrix. 29 | /// 30 | /// @see ext_matrix_uint3x4_sized 31 | typedef mat<3, 4, uint8, defaultp> u8mat3x4; 32 | 33 | /// 16 bit unsigned integer 3x4 matrix. 34 | /// 35 | /// @see ext_matrix_uint3x4_sized 36 | typedef mat<3, 4, uint16, defaultp> u16mat3x4; 37 | 38 | /// 32 bit unsigned integer 3x4 matrix. 39 | /// 40 | /// @see ext_matrix_uint3x4_sized 41 | typedef mat<3, 4, uint32, defaultp> u32mat3x4; 42 | 43 | /// 64 bit unsigned integer 3x4 matrix. 44 | /// 45 | /// @see ext_matrix_uint3x4_sized 46 | typedef mat<3, 4, uint64, defaultp> u64mat3x4; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/matrix_uint4x2_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint4x2_sized 2 | /// @file glm/ext/matrix_uint4x2_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint4x2_sized GLM_EXT_matrix_uint4x2_sized 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 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_uint4x2_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_uint4x2_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer 4x2 matrix. 29 | /// 30 | /// @see ext_matrix_uint4x2_sized 31 | typedef mat<4, 2, uint8, defaultp> u8mat4x2; 32 | 33 | /// 16 bit unsigned integer 4x2 matrix. 34 | /// 35 | /// @see ext_matrix_uint4x2_sized 36 | typedef mat<4, 2, uint16, defaultp> u16mat4x2; 37 | 38 | /// 32 bit unsigned integer 4x2 matrix. 39 | /// 40 | /// @see ext_matrix_uint4x2_sized 41 | typedef mat<4, 2, uint32, defaultp> u32mat4x2; 42 | 43 | /// 64 bit unsigned integer 4x2 matrix. 44 | /// 45 | /// @see ext_matrix_uint4x2_sized 46 | typedef mat<4, 2, uint64, defaultp> u64mat4x2; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/matrix_uint4x3_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_matrix_uint4x3_sized 2 | /// @file glm/ext/matrix_uint4x3_sized.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup ext_matrix_uint4x3_sized GLM_EXT_matrix_uint4x3_sized 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 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_matrix_uint4x3_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_matrix_uint4x3_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer 4x3 matrix. 29 | /// 30 | /// @see ext_matrix_uint4x3_sized 31 | typedef mat<4, 3, uint8, defaultp> u8mat4x3; 32 | 33 | /// 16 bit unsigned integer 4x3 matrix. 34 | /// 35 | /// @see ext_matrix_uint4x3_sized 36 | typedef mat<4, 3, uint16, defaultp> u16mat4x3; 37 | 38 | /// 32 bit unsigned integer 4x3 matrix. 39 | /// 40 | /// @see ext_matrix_uint4x3_sized 41 | typedef mat<4, 3, uint32, defaultp> u32mat4x3; 42 | 43 | /// 64 bit unsigned integer 4x3 matrix. 44 | /// 45 | /// @see ext_matrix_uint4x3_sized 46 | typedef mat<4, 3, uint64, defaultp> u64mat4x3; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/quaternion_float_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_quaternion_float_precision 2 | /// @file glm/ext/quaternion_float_precision.hpp 3 | /// 4 | /// @defgroup ext_quaternion_float_precision GLM_EXT_quaternion_float_precision 5 | /// @ingroup ext 6 | /// 7 | /// Exposes single-precision floating point quaternion type with various precision in term of ULPs. 8 | /// 9 | /// Include to use the features of this extension. 10 | 11 | #pragma once 12 | 13 | // Dependency: 14 | #include "../detail/type_quat.hpp" 15 | 16 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 17 | # pragma message("GLM: GLM_EXT_quaternion_float_precision extension included") 18 | #endif 19 | 20 | namespace glm 21 | { 22 | /// @addtogroup ext_quaternion_float_precision 23 | /// @{ 24 | 25 | /// Quaternion of single-precision floating-point numbers using high precision arithmetic in term of ULPs. 26 | typedef qua lowp_quat; 27 | 28 | /// Quaternion of single-precision floating-point numbers using high precision arithmetic in term of ULPs. 29 | typedef qua mediump_quat; 30 | 31 | /// Quaternion of single-precision floating-point numbers using high precision arithmetic in term of ULPs. 32 | typedef qua highp_quat; 33 | 34 | /// @} 35 | } //namespace glm 36 | 37 | -------------------------------------------------------------------------------- /libs/glm/ext/quaternion_geometric.inl: -------------------------------------------------------------------------------- 1 | namespace glm 2 | { 3 | template 4 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR T dot(qua const& x, qua const& y) 5 | { 6 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'dot' accepts only floating-point inputs"); 7 | return detail::compute_dot, T, detail::is_aligned::value>::call(x, y); 8 | } 9 | 10 | template 11 | GLM_FUNC_QUALIFIER T length(qua const& q) 12 | { 13 | return glm::sqrt(dot(q, q)); 14 | } 15 | 16 | template 17 | GLM_FUNC_QUALIFIER qua normalize(qua const& q) 18 | { 19 | T len = length(q); 20 | if(len <= static_cast(0)) // Problem 21 | return qua::wxyz(static_cast(1), static_cast(0), static_cast(0), static_cast(0)); 22 | T oneOverLen = static_cast(1) / len; 23 | return qua::wxyz(q.w * oneOverLen, q.x * oneOverLen, q.y * oneOverLen, q.z * oneOverLen); 24 | } 25 | 26 | template 27 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua cross(qua const& q1, qua const& q2) 28 | { 29 | return qua::wxyz( 30 | q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z, 31 | q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y, 32 | q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z, 33 | q1.w * q2.z + q1.z * q2.w + q1.x * q2.y - q1.y * q2.x); 34 | } 35 | }//namespace glm 36 | 37 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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::wxyz(cos(AngleRad * static_cast(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin); 22 | } 23 | }//namespace glm 24 | 25 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'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 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/scalar_packing.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/glm/ext/scalar_packing.inl -------------------------------------------------------------------------------- /libs/glm/ext/scalar_relational.inl: -------------------------------------------------------------------------------- 1 | #include "../common.hpp" 2 | #include "../ext/scalar_int_sized.hpp" 3 | #include "../ext/scalar_uint_sized.hpp" 4 | #include "../detail/type_float.hpp" 5 | 6 | namespace glm 7 | { 8 | template 9 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool equal(genType const& x, genType const& y, genType const& epsilon) 10 | { 11 | return abs(x - y) <= epsilon; 12 | } 13 | 14 | template 15 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool notEqual(genType const& x, genType const& y, genType const& epsilon) 16 | { 17 | return abs(x - y) > epsilon; 18 | } 19 | 20 | template 21 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool equal(genType const& x, genType const& y, int MaxULPs) 22 | { 23 | detail::float_t const a(x); 24 | detail::float_t const b(y); 25 | 26 | // Different signs means they do not match. 27 | if(a.negative() != b.negative()) 28 | return false; 29 | 30 | // Find the difference in ULPs. 31 | typename detail::float_t::int_type const DiffULPs = abs(a.i - b.i); 32 | return DiffULPs <= MaxULPs; 33 | } 34 | 35 | template 36 | GLM_FUNC_QUALIFIER GLM_CONSTEXPR bool notEqual(genType const& x, genType const& y, int ULPs) 37 | { 38 | return !equal(x, y, ULPs); 39 | } 40 | }//namespace glm 41 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/vector_bool2_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_bool2_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec2.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 2 components vector of high qualifier bool numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<2, bool, highp> highp_bvec2; 17 | 18 | /// 2 components vector of medium qualifier bool numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<2, bool, mediump> mediump_bvec2; 23 | 24 | /// 2 components vector of low qualifier bool numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<2, bool, lowp> lowp_bvec2; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/vector_bool3_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_bool3_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec3.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 3 components vector of high qualifier bool numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<3, bool, highp> highp_bvec3; 17 | 18 | /// 3 components vector of medium qualifier bool numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<3, bool, mediump> mediump_bvec3; 23 | 24 | /// 3 components vector of low qualifier bool numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<3, bool, lowp> lowp_bvec3; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/vector_bool4_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/ext/vector_bool4_precision.hpp 3 | 4 | #pragma once 5 | #include "../detail/type_vec4.hpp" 6 | 7 | namespace glm 8 | { 9 | /// @addtogroup core_vector_precision 10 | /// @{ 11 | 12 | /// 4 components vector of high qualifier bool numbers. 13 | /// 14 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 15 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 16 | typedef vec<4, bool, highp> highp_bvec4; 17 | 18 | /// 4 components vector of medium qualifier bool numbers. 19 | /// 20 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 21 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 22 | typedef vec<4, bool, mediump> mediump_bvec4; 23 | 24 | /// 4 components vector of low qualifier bool numbers. 25 | /// 26 | /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors 27 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 28 | typedef vec<4, bool, lowp> lowp_bvec4; 29 | 30 | /// @} 31 | }//namespace glm 32 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/vector_double1_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_double1_precision 2 | /// @file glm/ext/vector_double1_precision.hpp 3 | /// 4 | /// @defgroup ext_vector_double1_precision GLM_EXT_vector_double1_precision 5 | /// @ingroup ext 6 | /// 7 | /// Exposes highp_dvec1, mediump_dvec1 and lowp_dvec1 types. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_double1 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_double1_precision extension included") 19 | #endif 20 | 21 | namespace glm 22 | { 23 | /// @addtogroup ext_vector_double1_precision 24 | /// @{ 25 | 26 | /// 1 component vector of double-precision floating-point numbers using high precision arithmetic in term of ULPs. 27 | typedef vec<1, double, highp> highp_dvec1; 28 | 29 | /// 1 component vector of double-precision floating-point numbers using medium precision arithmetic in term of ULPs. 30 | typedef vec<1, double, mediump> mediump_dvec1; 31 | 32 | /// 1 component vector of double-precision floating-point numbers using low precision arithmetic in term of ULPs. 33 | typedef vec<1, double, lowp> lowp_dvec1; 34 | 35 | /// @} 36 | }//namespace glm 37 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/vector_float1_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_float1_precision 2 | /// @file glm/ext/vector_float1_precision.hpp 3 | /// 4 | /// @defgroup ext_vector_float1_precision GLM_EXT_vector_float1_precision 5 | /// @ingroup ext 6 | /// 7 | /// Exposes highp_vec1, mediump_vec1 and lowp_vec1 types. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_vector_float1 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_float1_precision extension included") 19 | #endif 20 | 21 | namespace glm 22 | { 23 | /// @addtogroup ext_vector_float1_precision 24 | /// @{ 25 | 26 | /// 1 component vector of single-precision floating-point numbers using high precision arithmetic in term of ULPs. 27 | typedef vec<1, float, highp> highp_vec1; 28 | 29 | /// 1 component vector of single-precision floating-point numbers using medium precision arithmetic in term of ULPs. 30 | typedef vec<1, float, mediump> mediump_vec1; 31 | 32 | /// 1 component vector of single-precision floating-point numbers using low precision arithmetic in term of ULPs. 33 | typedef vec<1, float, lowp> lowp_vec1; 34 | 35 | /// @} 36 | }//namespace glm 37 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/vector_int1_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_int1_sized 2 | /// @file glm/ext/vector_int1_sized.hpp 3 | /// 4 | /// @defgroup ext_vector_int1_sized GLM_EXT_vector_int1_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized signed integer vector types. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_int_sized 12 | /// @see ext_vector_uint1_sized 13 | 14 | #pragma once 15 | 16 | #include "../ext/vector_int1.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_int1_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_int1_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer vector of 1 component type. 29 | /// 30 | /// @see ext_vector_int1_sized 31 | typedef vec<1, int8, defaultp> i8vec1; 32 | 33 | /// 16 bit signed integer vector of 1 component type. 34 | /// 35 | /// @see ext_vector_int1_sized 36 | typedef vec<1, int16, defaultp> i16vec1; 37 | 38 | /// 32 bit signed integer vector of 1 component type. 39 | /// 40 | /// @see ext_vector_int1_sized 41 | typedef vec<1, int32, defaultp> i32vec1; 42 | 43 | /// 64 bit signed integer vector of 1 component type. 44 | /// 45 | /// @see ext_vector_int1_sized 46 | typedef vec<1, int64, defaultp> i64vec1; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/vector_int2_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_int2_sized 2 | /// @file glm/ext/vector_int2_sized.hpp 3 | /// 4 | /// @defgroup ext_vector_int2_sized GLM_EXT_vector_int2_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized signed integer vector of 2 components type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_int_sized 12 | /// @see ext_vector_uint2_sized 13 | 14 | #pragma once 15 | 16 | #include "../ext/vector_int2.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_int2_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_int2_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer vector of 2 components type. 29 | /// 30 | /// @see ext_vector_int2_sized 31 | typedef vec<2, int8, defaultp> i8vec2; 32 | 33 | /// 16 bit signed integer vector of 2 components type. 34 | /// 35 | /// @see ext_vector_int2_sized 36 | typedef vec<2, int16, defaultp> i16vec2; 37 | 38 | /// 32 bit signed integer vector of 2 components type. 39 | /// 40 | /// @see ext_vector_int2_sized 41 | typedef vec<2, int32, defaultp> i32vec2; 42 | 43 | /// 64 bit signed integer vector of 2 components type. 44 | /// 45 | /// @see ext_vector_int2_sized 46 | typedef vec<2, int64, defaultp> i64vec2; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/vector_int3_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_int3_sized 2 | /// @file glm/ext/vector_int3_sized.hpp 3 | /// 4 | /// @defgroup ext_vector_int3_sized GLM_EXT_vector_int3_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized signed integer vector of 3 components type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_int_sized 12 | /// @see ext_vector_uint3_sized 13 | 14 | #pragma once 15 | 16 | #include "../ext/vector_int3.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_int3_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_int3_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer vector of 3 components type. 29 | /// 30 | /// @see ext_vector_int3_sized 31 | typedef vec<3, int8, defaultp> i8vec3; 32 | 33 | /// 16 bit signed integer vector of 3 components type. 34 | /// 35 | /// @see ext_vector_int3_sized 36 | typedef vec<3, int16, defaultp> i16vec3; 37 | 38 | /// 32 bit signed integer vector of 3 components type. 39 | /// 40 | /// @see ext_vector_int3_sized 41 | typedef vec<3, int32, defaultp> i32vec3; 42 | 43 | /// 64 bit signed integer vector of 3 components type. 44 | /// 45 | /// @see ext_vector_int3_sized 46 | typedef vec<3, int64, defaultp> i64vec3; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/vector_int4_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_int4_sized 2 | /// @file glm/ext/vector_int4_sized.hpp 3 | /// 4 | /// @defgroup ext_vector_int4_sized GLM_EXT_vector_int4_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized signed integer vector of 4 components type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_int_sized 12 | /// @see ext_vector_uint4_sized 13 | 14 | #pragma once 15 | 16 | #include "../ext/vector_int4.hpp" 17 | #include "../ext/scalar_int_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_int4_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_int4_sized 26 | /// @{ 27 | 28 | /// 8 bit signed integer vector of 4 components type. 29 | /// 30 | /// @see ext_vector_int4_sized 31 | typedef vec<4, int8, defaultp> i8vec4; 32 | 33 | /// 16 bit signed integer vector of 4 components type. 34 | /// 35 | /// @see ext_vector_int4_sized 36 | typedef vec<4, int16, defaultp> i16vec4; 37 | 38 | /// 32 bit signed integer vector of 4 components type. 39 | /// 40 | /// @see ext_vector_int4_sized 41 | typedef vec<4, int32, defaultp> i32vec4; 42 | 43 | /// 64 bit signed integer vector of 4 components type. 44 | /// 45 | /// @see ext_vector_int4_sized 46 | typedef vec<4, int64, defaultp> i64vec4; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/vector_packing.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/glm/ext/vector_packing.inl -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/vector_uint1_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_uint1_sized 2 | /// @file glm/ext/vector_uint1_sized.hpp 3 | /// 4 | /// @defgroup ext_vector_uint1_sized GLM_EXT_vector_uint1_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized unsigned integer vector types. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_uint_sized 12 | /// @see ext_vector_int1_sized 13 | 14 | #pragma once 15 | 16 | #include "../ext/vector_uint1.hpp" 17 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_uint1_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_uint1_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer vector of 1 component type. 29 | /// 30 | /// @see ext_vector_uint1_sized 31 | typedef vec<1, uint8, defaultp> u8vec1; 32 | 33 | /// 16 bit unsigned integer vector of 1 component type. 34 | /// 35 | /// @see ext_vector_uint1_sized 36 | typedef vec<1, uint16, defaultp> u16vec1; 37 | 38 | /// 32 bit unsigned integer vector of 1 component type. 39 | /// 40 | /// @see ext_vector_uint1_sized 41 | typedef vec<1, uint32, defaultp> u32vec1; 42 | 43 | /// 64 bit unsigned integer vector of 1 component type. 44 | /// 45 | /// @see ext_vector_uint1_sized 46 | typedef vec<1, uint64, defaultp> u64vec1; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/vector_uint2_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_uint2_sized 2 | /// @file glm/ext/vector_uint2_sized.hpp 3 | /// 4 | /// @defgroup ext_vector_uint2_sized GLM_EXT_vector_uint2_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized unsigned integer vector of 2 components type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_uint_sized 12 | /// @see ext_vector_int2_sized 13 | 14 | #pragma once 15 | 16 | #include "../ext/vector_uint2.hpp" 17 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_uint2_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_uint2_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer vector of 2 components type. 29 | /// 30 | /// @see ext_vector_uint2_sized 31 | typedef vec<2, uint8, defaultp> u8vec2; 32 | 33 | /// 16 bit unsigned integer vector of 2 components type. 34 | /// 35 | /// @see ext_vector_uint2_sized 36 | typedef vec<2, uint16, defaultp> u16vec2; 37 | 38 | /// 32 bit unsigned integer vector of 2 components type. 39 | /// 40 | /// @see ext_vector_uint2_sized 41 | typedef vec<2, uint32, defaultp> u32vec2; 42 | 43 | /// 64 bit unsigned integer vector of 2 components type. 44 | /// 45 | /// @see ext_vector_uint2_sized 46 | typedef vec<2, uint64, defaultp> u64vec2; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/vector_uint3_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_uint3_sized 2 | /// @file glm/ext/vector_uint3_sized.hpp 3 | /// 4 | /// @defgroup ext_vector_uint3_sized GLM_EXT_vector_uint3_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized unsigned integer vector of 3 components type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_uint_sized 12 | /// @see ext_vector_int3_sized 13 | 14 | #pragma once 15 | 16 | #include "../ext/vector_uint3.hpp" 17 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_uint3_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_uint3_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer vector of 3 components type. 29 | /// 30 | /// @see ext_vector_uint3_sized 31 | typedef vec<3, uint8, defaultp> u8vec3; 32 | 33 | /// 16 bit unsigned integer vector of 3 components type. 34 | /// 35 | /// @see ext_vector_uint3_sized 36 | typedef vec<3, uint16, defaultp> u16vec3; 37 | 38 | /// 32 bit unsigned integer vector of 3 components type. 39 | /// 40 | /// @see ext_vector_uint3_sized 41 | typedef vec<3, uint32, defaultp> u32vec3; 42 | 43 | /// 64 bit unsigned integer vector of 3 components type. 44 | /// 45 | /// @see ext_vector_uint3_sized 46 | typedef vec<3, uint64, defaultp> u64vec3; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/ext/vector_uint4_sized.hpp: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_uint4_sized 2 | /// @file glm/ext/vector_uint4_sized.hpp 3 | /// 4 | /// @defgroup ext_vector_uint4_sized GLM_EXT_vector_uint4_sized 5 | /// @ingroup ext 6 | /// 7 | /// Exposes sized unsigned integer vector of 4 components type. 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @see ext_scalar_uint_sized 12 | /// @see ext_vector_int4_sized 13 | 14 | #pragma once 15 | 16 | #include "../ext/vector_uint4.hpp" 17 | #include "../ext/scalar_uint_sized.hpp" 18 | 19 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 20 | # pragma message("GLM: GLM_EXT_vector_uint4_sized extension included") 21 | #endif 22 | 23 | namespace glm 24 | { 25 | /// @addtogroup ext_vector_uint4_sized 26 | /// @{ 27 | 28 | /// 8 bit unsigned integer vector of 4 components type. 29 | /// 30 | /// @see ext_vector_uint4_sized 31 | typedef vec<4, uint8, defaultp> u8vec4; 32 | 33 | /// 16 bit unsigned integer vector of 4 components type. 34 | /// 35 | /// @see ext_vector_uint4_sized 36 | typedef vec<4, uint16, defaultp> u16vec4; 37 | 38 | /// 32 bit unsigned integer vector of 4 components type. 39 | /// 40 | /// @see ext_vector_uint4_sized 41 | typedef vec<4, uint32, defaultp> u32vec4; 42 | 43 | /// 64 bit unsigned integer vector of 4 components type. 44 | /// 45 | /// @see ext_vector_uint4_sized 46 | typedef vec<4, uint64, defaultp> u64vec4; 47 | 48 | /// @} 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /libs/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. Useful to compute mipmap count from the texture size. 36 | /// @see gtc_integer 37 | template 38 | GLM_FUNC_DECL vec log2(vec const& v); 39 | 40 | /// @} 41 | } //namespace glm 42 | 43 | #include "integer.inl" 44 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/gtc/matrix_access.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_matrix_access 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER genType row 7 | ( 8 | genType const& m, 9 | length_t index, 10 | typename genType::row_type const& x 11 | ) 12 | { 13 | assert(index >= 0 && index < m[0].length()); 14 | 15 | genType Result = m; 16 | for(length_t i = 0; i < m.length(); ++i) 17 | Result[i][index] = x[i]; 18 | return Result; 19 | } 20 | 21 | template 22 | GLM_FUNC_QUALIFIER typename genType::row_type row 23 | ( 24 | genType const& m, 25 | length_t index 26 | ) 27 | { 28 | assert(index >= 0 && index < m[0].length()); 29 | 30 | typename genType::row_type Result(0); 31 | for(length_t i = 0; i < m.length(); ++i) 32 | Result[i] = m[i][index]; 33 | return Result; 34 | } 35 | 36 | template 37 | GLM_FUNC_QUALIFIER genType column 38 | ( 39 | genType const& m, 40 | length_t index, 41 | typename genType::col_type const& x 42 | ) 43 | { 44 | assert(index >= 0 && index < m.length()); 45 | 46 | genType Result = m; 47 | Result[index] = x; 48 | return Result; 49 | } 50 | 51 | template 52 | GLM_FUNC_QUALIFIER typename genType::col_type column 53 | ( 54 | genType const& m, 55 | length_t index 56 | ) 57 | { 58 | assert(index >= 0 && index < m.length()); 59 | 60 | return m[index]; 61 | } 62 | }//namespace glm 63 | -------------------------------------------------------------------------------- /libs/glm/gtc/matrix_transform.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_matrix_transform 2 | /// @file glm/gtc/matrix_transform.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_transform 6 | /// @see gtx_transform2 7 | /// 8 | /// @defgroup gtc_matrix_transform GLM_GTC_matrix_transform 9 | /// @ingroup gtc 10 | /// 11 | /// Include to use the features of this extension. 12 | /// 13 | /// Defines functions that generate common transformation matrices. 14 | /// 15 | /// The matrices generated by this extension use standard OpenGL fixed-function 16 | /// conventions. For example, the lookAt function generates a transform from world 17 | /// space into the specific eye space that the projective matrix functions 18 | /// (perspective, ortho, etc) are designed to expect. The OpenGL compatibility 19 | /// specifications defines the particular layout of this eye space. 20 | 21 | #pragma once 22 | 23 | // Dependencies 24 | #include "../mat4x4.hpp" 25 | #include "../vec2.hpp" 26 | #include "../vec3.hpp" 27 | #include "../vec4.hpp" 28 | #include "../ext/matrix_projection.hpp" 29 | #include "../ext/matrix_clip_space.hpp" 30 | #include "../ext/matrix_transform.hpp" 31 | 32 | #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 33 | # pragma message("GLM: GLM_GTC_matrix_transform extension included") 34 | #endif 35 | 36 | #include "matrix_transform.inl" 37 | -------------------------------------------------------------------------------- /libs/glm/gtc/matrix_transform.inl: -------------------------------------------------------------------------------- 1 | #include "../geometric.hpp" 2 | #include "../trigonometric.hpp" 3 | #include "../matrix.hpp" 4 | -------------------------------------------------------------------------------- /libs/glm/gtc/quaternion_simd.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/glm/gtc/quaternion_simd.inl -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/gtc/type_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_precision 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/gtx/closest_point.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_closest_point 2 | 3 | namespace glm 4 | { 5 | template 6 | GLM_FUNC_QUALIFIER vec<3, T, Q> closestPointOnLine 7 | ( 8 | vec<3, T, Q> const& point, 9 | vec<3, T, Q> const& a, 10 | vec<3, T, Q> const& b 11 | ) 12 | { 13 | T LineLength = distance(a, b); 14 | vec<3, T, Q> Vector = point - a; 15 | vec<3, T, Q> LineDirection = (b - a) / LineLength; 16 | 17 | // Project Vector to LineDirection to get the distance of point from a 18 | T Distance = dot(Vector, LineDirection); 19 | 20 | if(Distance <= T(0)) return a; 21 | if(Distance >= LineLength) return b; 22 | return a + LineDirection * Distance; 23 | } 24 | 25 | template 26 | GLM_FUNC_QUALIFIER vec<2, T, Q> closestPointOnLine 27 | ( 28 | vec<2, T, Q> const& point, 29 | vec<2, T, Q> const& a, 30 | vec<2, T, Q> const& b 31 | ) 32 | { 33 | T LineLength = distance(a, b); 34 | vec<2, T, Q> Vector = point - a; 35 | vec<2, T, Q> LineDirection = (b - a) / LineLength; 36 | 37 | // Project Vector to LineDirection to get the distance of point from a 38 | T Distance = dot(Vector, LineDirection); 39 | 40 | if(Distance <= T(0)) return a; 41 | if(Distance >= LineLength) return b; 42 | return a + LineDirection * Distance; 43 | } 44 | 45 | }//namespace glm 46 | -------------------------------------------------------------------------------- /libs/glm/gtx/extend.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_extend 2 | /// @file glm/gtx/extend.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_extend GLM_GTX_extend 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 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "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." 20 | #elif GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 21 | # pragma message("GLM: GLM_GTX_extend extension included") 22 | #endif 23 | 24 | namespace glm 25 | { 26 | /// @addtogroup gtx_extend 27 | /// @{ 28 | 29 | /// Extends of Length the Origin position using the (Source - Origin) direction. 30 | /// @see gtx_extend 31 | template 32 | GLM_FUNC_DECL genType extend( 33 | genType const& Origin, 34 | genType const& Source, 35 | typename genType::value_type const Length); 36 | 37 | /// @} 38 | }//namespace glm 39 | 40 | #include "extend.inl" 41 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 GLM_CONSTEXPR 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 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'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 GLM_CONSTEXPR 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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/gtx/log_base.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_log_base 2 | /// @file glm/gtx/log_base.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_log_base GLM_GTX_log_base 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Logarithm for any base. base can be a vector or a scalar. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_log_base 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." 20 | #elif GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 21 | # pragma message("GLM: GLM_GTX_log_base extension included") 22 | #endif 23 | 24 | namespace glm 25 | { 26 | /// @addtogroup gtx_log_base 27 | /// @{ 28 | 29 | /// Logarithm for any base. 30 | /// From GLM_GTX_log_base. 31 | template 32 | GLM_FUNC_DECL genType log( 33 | genType const& x, 34 | genType const& base); 35 | 36 | /// Logarithm for any base. 37 | /// From GLM_GTX_log_base. 38 | template 39 | GLM_FUNC_DECL vec sign( 40 | vec const& x, 41 | vec const& base); 42 | 43 | /// @} 44 | }//namespace glm 45 | 46 | #include "log_base.inl" 47 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "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." 20 | #elif GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 21 | # pragma message("GLM: GLM_GTX_mixed_product extension included") 22 | #endif 23 | 24 | namespace glm 25 | { 26 | /// @addtogroup gtx_mixed_product 27 | /// @{ 28 | 29 | /// @brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension) 30 | template 31 | GLM_FUNC_DECL T mixedProduct( 32 | vec<3, T, Q> const& v1, 33 | vec<3, T, Q> const& v2, 34 | vec<3, T, Q> const& v3); 35 | 36 | /// @} 37 | }// namespace glm 38 | 39 | #include "mixed_product.inl" 40 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "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." 21 | #elif GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 22 | # pragma message("GLM: GLM_GTX_normal extension included") 23 | #endif 24 | 25 | namespace glm 26 | { 27 | /// @addtogroup gtx_normal 28 | /// @{ 29 | 30 | /// Computes triangle normal from triangle points. 31 | /// 32 | /// @see gtx_normal 33 | template 34 | 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); 35 | 36 | /// @} 37 | }//namespace glm 38 | 39 | #include "normal.inl" 40 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/gtx/optimum_pow.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_optimum_pow 2 | /// @file glm/gtx/optimum_pow.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_optimum_pow GLM_GTX_optimum_pow 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Integer exponentiation of power functions. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_optimum_pow 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." 20 | #elif GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 21 | # pragma message("GLM: GLM_GTX_optimum_pow extension included") 22 | #endif 23 | 24 | namespace glm 25 | { 26 | /// @addtogroup gtx_optimum_pow 27 | /// @{ 28 | 29 | /// Returns x raised to the power of 2. 30 | /// 31 | /// @see gtx_optimum_pow 32 | template 33 | GLM_FUNC_DECL genType pow2(genType const& x); 34 | 35 | /// Returns x raised to the power of 3. 36 | /// 37 | /// @see gtx_optimum_pow 38 | template 39 | GLM_FUNC_DECL genType pow3(genType const& x); 40 | 41 | /// Returns x raised to the power of 4. 42 | /// 43 | /// @see gtx_optimum_pow 44 | template 45 | GLM_FUNC_DECL genType pow4(genType const& x); 46 | 47 | /// @} 48 | }//namespace glm 49 | 50 | #include "optimum_pow.inl" 51 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/gtx/perpendicular.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_perpendicular 2 | /// @file glm/gtx/perpendicular.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_projection (dependence) 6 | /// 7 | /// @defgroup gtx_perpendicular GLM_GTX_perpendicular 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Perpendicular of a vector from other one 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | #include "../gtx/projection.hpp" 19 | 20 | #ifndef GLM_ENABLE_EXPERIMENTAL 21 | # error "GLM: GLM_GTX_perpendicular 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 | #elif GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_perpendicular extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_perpendicular 29 | /// @{ 30 | 31 | //! Projects x a perpendicular axis of Normal. 32 | //! From GLM_GTX_perpendicular extension. 33 | template 34 | GLM_FUNC_DECL genType perp(genType const& x, genType const& Normal); 35 | 36 | /// @} 37 | }//namespace glm 38 | 39 | #include "perpendicular.inl" 40 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/gtx/projection.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_projection 2 | /// @file glm/gtx/projection.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_projection GLM_GTX_projection 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Projection of a vector to other one 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../geometric.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_projection 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." 20 | #elif GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 21 | # pragma message("GLM: GLM_GTX_projection extension included") 22 | #endif 23 | 24 | namespace glm 25 | { 26 | /// @addtogroup gtx_projection 27 | /// @{ 28 | 29 | /// Projects x on Normal. 30 | /// 31 | /// @param[in] x A vector to project 32 | /// @param[in] Normal A normal that doesn't need to be of unit length. 33 | /// 34 | /// @see gtx_projection 35 | template 36 | GLM_FUNC_DECL genType proj(genType const& x, genType const& Normal); 37 | 38 | /// @} 39 | }//namespace glm 40 | 41 | #include "projection.inl" 42 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/gtx/raw_data.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_raw_data 2 | /// @file glm/gtx/raw_data.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_raw_data GLM_GTX_raw_data 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Projection of a vector to other one 12 | 13 | #pragma once 14 | 15 | // Dependencies 16 | #include "../ext/scalar_uint_sized.hpp" 17 | #include "../detail/setup.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_raw_data 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 | #elif GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 22 | # pragma message("GLM: GLM_GTX_raw_data extension included") 23 | #endif 24 | 25 | namespace glm 26 | { 27 | /// @addtogroup gtx_raw_data 28 | /// @{ 29 | 30 | //! Type for byte numbers. 31 | //! From GLM_GTX_raw_data extension. 32 | typedef detail::uint8 byte; 33 | 34 | //! Type for word numbers. 35 | //! From GLM_GTX_raw_data extension. 36 | typedef detail::uint16 word; 37 | 38 | //! Type for dword numbers. 39 | //! From GLM_GTX_raw_data extension. 40 | typedef detail::uint32 dword; 41 | 42 | //! Type for qword numbers. 43 | //! From GLM_GTX_raw_data extension. 44 | typedef detail::uint64 qword; 45 | 46 | /// @} 47 | }// namespace glm 48 | 49 | #include "raw_data.inl" 50 | -------------------------------------------------------------------------------- /libs/glm/gtx/raw_data.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_raw_data 2 | 3 | -------------------------------------------------------------------------------- /libs/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 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_scalar_relational 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." 20 | #elif GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 21 | # pragma message("GLM: GLM_GTX_scalar_relational extension included") 22 | #endif 23 | 24 | namespace glm 25 | { 26 | /// @addtogroup gtx_scalar_relational 27 | /// @{ 28 | 29 | 30 | 31 | /// @} 32 | }//namespace glm 33 | 34 | #include "scalar_relational.inl" 35 | -------------------------------------------------------------------------------- /libs/glm/gtx/std_based_type.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_std_based_type 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /libs/glm/gtx/string_cast.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_string_cast 2 | /// @file glm/gtx/string_cast.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_integer (dependence) 6 | /// @see gtx_quaternion (dependence) 7 | /// 8 | /// @defgroup gtx_string_cast GLM_GTX_string_cast 9 | /// @ingroup gtx 10 | /// 11 | /// Include to use the features of this extension. 12 | /// 13 | /// Setup strings for GLM type values 14 | 15 | #pragma once 16 | 17 | // Dependency: 18 | #include "../glm.hpp" 19 | #include "../gtc/type_precision.hpp" 20 | #include "../gtc/quaternion.hpp" 21 | #include "../gtx/dual_quaternion.hpp" 22 | #include 23 | #include 24 | #include 25 | 26 | #ifndef GLM_ENABLE_EXPERIMENTAL 27 | # error "GLM: GLM_GTX_string_cast 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." 28 | #elif GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 29 | # pragma message("GLM: GLM_GTX_string_cast extension included") 30 | #endif 31 | 32 | namespace glm 33 | { 34 | /// @addtogroup gtx_string_cast 35 | /// @{ 36 | 37 | /// Create a string from a GLM vector or matrix typed variable. 38 | /// @see gtx_string_cast extension. 39 | template 40 | GLM_FUNC_DECL std::string to_string(genType const& x); 41 | 42 | /// @} 43 | }//namespace glm 44 | 45 | #include "string_cast.inl" 46 | -------------------------------------------------------------------------------- /libs/glm/gtx/texture.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_texture 2 | /// @file glm/gtx/texture.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_texture GLM_GTX_texture 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 "../gtc/integer.hpp" 18 | #include "../gtx/component_wise.hpp" 19 | 20 | #ifndef GLM_ENABLE_EXPERIMENTAL 21 | # error "GLM: GLM_GTX_texture 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 | #elif GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_texture extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_texture 29 | /// @{ 30 | 31 | /// Compute the number of mipmaps levels necessary to create a mipmap complete texture 32 | /// 33 | /// @param Extent Extent of the texture base level mipmap 34 | /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector 35 | /// @tparam T Floating-point or signed integer scalar types 36 | /// @tparam Q Value from qualifier enum 37 | template 38 | T levels(vec const& Extent); 39 | 40 | /// @} 41 | }// namespace glm 42 | 43 | #include "texture.inl" 44 | 45 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/glm/gtx/type_aligned.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_type_aligned 2 | 3 | namespace glm 4 | { 5 | 6 | } 7 | -------------------------------------------------------------------------------- /libs/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 | #ifndef GLM_ENABLE_EXPERIMENTAL 22 | # error "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." 23 | #elif GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_wrap extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_wrap 30 | /// @{ 31 | 32 | /// @} 33 | }// namespace glm 34 | 35 | #include "wrap.inl" 36 | -------------------------------------------------------------------------------- /libs/glm/gtx/wrap.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_wrap 2 | 3 | namespace glm 4 | { 5 | 6 | }//namespace glm 7 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/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 | -------------------------------------------------------------------------------- /libs/lua/liblua53.a.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/lua/liblua53.a.lib -------------------------------------------------------------------------------- /libs/lua/lua.hpp: -------------------------------------------------------------------------------- 1 | // lua.hpp 2 | // Lua header files for C++ 3 | // <> not supplied automatically because Lua also compiles as C++ 4 | 5 | extern "C" { 6 | #include "lua.h" 7 | #include "lualib.h" 8 | #include "lauxlib.h" 9 | } 10 | -------------------------------------------------------------------------------- /libs/lua/lua53.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/libs/lua/lua53.dll -------------------------------------------------------------------------------- /libs/sol/LICENCE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2013-2020 Rapptz, ThePhD, and contributors 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 6 | this software and associated documentation files (the "Software"), to deal in 7 | the Software without restriction, including without limitation the rights to 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 9 | the Software, and to permit persons to whom the Software is furnished to do so, 10 | subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -------------------------------------------------------------------------------- /premake5.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/luizfelipemb/MitoEngine2D/40e2a202906bfef7c887b0eae77764ab3e694445/premake5.exe -------------------------------------------------------------------------------- /src/AssetStore/RendererManager.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | 5 | struct WindowSettings 6 | { 7 | inline static int FPS; 8 | inline static int WindowWidth; 9 | inline static int WindowHeight; 10 | inline static std::string WindowName; 11 | inline static std::string IconImageLocation; 12 | static int GetWidth() { return WindowWidth; } 13 | static int GetHeight() { return WindowHeight; } 14 | }; 15 | 16 | class RendererManager 17 | { 18 | public: 19 | ~RendererManager(); 20 | static void Initialize(); 21 | static void ClearFrameRender(); 22 | static void DrawFrameRender(); 23 | 24 | inline static SDL_Window* Window; 25 | inline static SDL_Renderer* Renderer; 26 | }; 27 | -------------------------------------------------------------------------------- /src/Events/CollisionEnterEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "glm.hpp" 4 | #include "Event.h" 5 | 6 | class GameObject; 7 | 8 | class CollisionEnterEvent : public Event 9 | { 10 | public: 11 | CollisionEnterEvent(const std::shared_ptr& other,glm::vec2 direction) 12 | : Other(other), Direction(direction) 13 | { 14 | } 15 | const std::shared_ptr& Other; 16 | glm::vec2 Direction; 17 | }; 18 | -------------------------------------------------------------------------------- /src/Events/CollisionExitEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "Event.h" 4 | class GameObject; 5 | 6 | class CollisionExitEvent : public Event 7 | { 8 | public: 9 | CollisionExitEvent(const std::shared_ptr& other) 10 | : Other(other) 11 | { 12 | } 13 | const std::shared_ptr& Other; 14 | }; 15 | -------------------------------------------------------------------------------- /src/Events/CollisionStayEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | #include "Event.h" 5 | 6 | class GameObject; 7 | 8 | class CollisionStayEvent : public Event 9 | { 10 | public: 11 | CollisionStayEvent(const std::shared_ptr& other) 12 | : Other(other) 13 | { 14 | } 15 | const std::shared_ptr& Other; 16 | }; 17 | 18 | -------------------------------------------------------------------------------- /src/Events/Event.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class Event 4 | { 5 | public: 6 | Event() = default; 7 | }; 8 | -------------------------------------------------------------------------------- /src/Events/GameObjectCreatedEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Event.h" 3 | 4 | class GameObjectCreatedEvent : public Event 5 | { 6 | 7 | }; 8 | -------------------------------------------------------------------------------- /src/Events/GlobalEventBus.cpp: -------------------------------------------------------------------------------- 1 | #include "GlobalEventBus.h" 2 | 3 | EventBus GlobalEventBus::m_eventBus; 4 | -------------------------------------------------------------------------------- /src/Events/GlobalEventBus.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "EventBus.h" 3 | 4 | class GlobalEventBus 5 | { 6 | public: 7 | GlobalEventBus() = delete; 8 | 9 | static void Reset() { 10 | m_eventBus.Reset(); 11 | } 12 | 13 | template 14 | static void SubscribeToEvent(TOwner* ownerInstance, void (TOwner::* callbackFunction)(TEvent&)) { 15 | m_eventBus.SubscribeToEvent(ownerInstance, callbackFunction); 16 | } 17 | 18 | template 19 | static void SubscribeToEvent(std::function callbackFunction) { 20 | m_eventBus.SubscribeToEvent(callbackFunction); 21 | } 22 | 23 | template 24 | static void EmitEvent(TArgs&& ...args) { 25 | m_eventBus.EmitEvent(std::forward(args)...); 26 | } 27 | template 28 | static void UnsubscribeFromOwner(TOwner* ownerInstance) { 29 | m_eventBus.UnsubscribeFromOwner(ownerInstance); 30 | } 31 | 32 | private: 33 | static EventBus m_eventBus; 34 | }; -------------------------------------------------------------------------------- /src/Events/KeyPressedEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include "Event.h" 5 | 6 | class KeyPressedEvent : public Event 7 | { 8 | public: 9 | SDL_Keycode Symbol; 10 | KeyPressedEvent(SDL_Keycode symbol) : Symbol(symbol) {} 11 | }; -------------------------------------------------------------------------------- /src/Events/KeyReleasedEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | class KeyReleasedEvent : public Event 5 | { 6 | public: 7 | SDL_Keycode Symbol; 8 | KeyReleasedEvent(SDL_Keycode symbol) : Symbol(symbol) {} 9 | }; 10 | 11 | -------------------------------------------------------------------------------- /src/Events/MouseButtonPressedEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Event.h" 3 | #include "../Logger/Logger.h" 4 | 5 | class MouseButtonPressedEvent: public Event 6 | { 7 | public: 8 | MouseButtonPressedEvent(int button, glm::vec2 pos): Button(button), Position(pos) 9 | { 10 | Logger::Log("Clicked button id:" + std::to_string(button) + 11 | " x:"+std::to_string(Position.x)+" y:"+std::to_string(Position.y)); 12 | } 13 | int Button; 14 | glm::vec2 Position; 15 | }; 16 | -------------------------------------------------------------------------------- /src/Events/MouseInteractedEvent.cpp: -------------------------------------------------------------------------------- 1 | #include "MouseInteractedEvent.h" 2 | -------------------------------------------------------------------------------- /src/Events/MouseInteractedEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Event.h" 3 | 4 | class MouseInteractedEvent : public Event 5 | { 6 | public: 7 | MouseInteractedEvent() = default; 8 | }; 9 | -------------------------------------------------------------------------------- /src/Events/OpenLevelEvent.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include "Event.h" 6 | 7 | class OpenLevelEvent : public Event 8 | { 9 | public: 10 | OpenLevelEvent(std::string levelName) : LevelName(levelName) 11 | {} 12 | std::string LevelName; 13 | }; 14 | -------------------------------------------------------------------------------- /src/Game/Game.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include "../GameObjects/GameObject.h" 5 | #include "../LuaScripting/LuaScript.h" 6 | 7 | class OpenLevelEvent; 8 | class EventBus; 9 | 10 | inline bool g_DebugMode = false; 11 | 12 | class Game 13 | { 14 | public: 15 | Game(); 16 | ~Game(); 17 | void Initialize(); 18 | void SwitchLevel(OpenLevelEvent& levelName); 19 | void Run(); 20 | void ProcessInput(); 21 | void Update(); 22 | void Destroy(); 23 | private: 24 | int m_millisecsPerFrame; 25 | bool m_isRunning = false; 26 | int m_msPreviousFrame = 0; 27 | std::string m_nextLevelName; 28 | bool m_canChangeLevel = false; 29 | std::unique_ptr m_registry; 30 | LuaScript m_luaScript; 31 | }; 32 | -------------------------------------------------------------------------------- /src/GameObjects/Systems/CollisionSystem.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | #include 5 | 6 | class GameObject; 7 | 8 | class CollisionSystem 9 | { 10 | public: 11 | bool CheckAABBCollision(double aX, double aY, double aW, double aH, double bX, 12 | double bY, double bW, double bH); 13 | glm::vec2 GetCollisionDirection(double aX, double aY, double aW, double aH, 14 | double bX, double bY, double bW, double bH); 15 | void CalculateCollisions(std::vector>& m_gameObjects); 16 | 17 | private: 18 | std::unordered_multimap m_objectsColliding; 19 | }; 20 | -------------------------------------------------------------------------------- /src/GameObjects/Systems/RenderSystem.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | #include 5 | 6 | class GameObjectCreatedEvent; 7 | class GameObject; 8 | 9 | class RenderSystem 10 | { 11 | public: 12 | RenderSystem(std::vector>& gameObjects); 13 | void SortByLayer(); 14 | void Update(); 15 | void OnObjectCreation(GameObjectCreatedEvent& gameObjectCreatedEvent); 16 | private: 17 | std::vector>& m_gameObjects; 18 | std::map>> layeredGameObjects; 19 | }; 20 | -------------------------------------------------------------------------------- /src/Logger/Logger.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | enum LogType 7 | { 8 | LOG_INFO, 9 | LOG_WARNING, 10 | LOG_LUA, 11 | LOG_ERROR 12 | }; 13 | 14 | struct LogEntry 15 | { 16 | LogType Type; 17 | std::string Message; 18 | }; 19 | 20 | class Logger 21 | { 22 | public: 23 | static std::vector Messages; 24 | static void Log(const std::string& message); 25 | static void Lua(const std::string& message); 26 | static void Err(const std::string& message); 27 | static void Wrn(const std::string& message); 28 | }; 29 | -------------------------------------------------------------------------------- /src/LuaScripting/LuaScript.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "../GameObjects/GameObject.h" 4 | 5 | class LuaScript 6 | { 7 | public: 8 | void SettingsSetup(); 9 | void LoadLuaBindings(); 10 | void LoadLuaKeys(); 11 | void EmitOpenLevel(const std::string& levelName); 12 | void LoadLevel(std::string name); 13 | GameObject* SpawnGameObject(sol::table entity); 14 | GameObject* SpawnPrefab(std::string name); 15 | void AddScriptComponent(GameObject* gameObject, const std::string& scriptName); 16 | private: 17 | sol::state lua; 18 | const std::string SCRIPTS_PATH = "./assets/scripts/"; 19 | const std::string LEVELS_PATH = "./assets/levels/"; 20 | const std::string SETTINGS_PATH = "./assets/settings/"; 21 | }; 22 | -------------------------------------------------------------------------------- /src/imgui/LICENSE.txt: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2014-2024 Omar Cornut 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /src/main.cpp: -------------------------------------------------------------------------------- 1 | #include "./Game/Game.h" 2 | #include 3 | 4 | struct AllocationMetrics 5 | { 6 | uint32_t TotalAllocated = 0; 7 | uint32_t TotalFreed = 0; 8 | 9 | uint32_t CurrentUsage(){ return TotalAllocated - TotalFreed; } 10 | }; 11 | static AllocationMetrics s_AllocationMetrics; 12 | 13 | void* operator new(size_t size) 14 | { 15 | s_AllocationMetrics.TotalAllocated += size; 16 | return malloc(size); 17 | } 18 | void operator delete(void* memory,size_t size) 19 | { 20 | s_AllocationMetrics.TotalFreed += size; 21 | free(memory); 22 | } 23 | static void PrintMemoryUsage() 24 | { 25 | std::cout<<"Memory Usage: "<