├── LICENSE ├── README.md ├── assets └── textures │ ├── earth_map.jpg │ └── readme │ ├── output_ch08_1000spp.jpg │ ├── output_cornell_smoke_scene_500spp.jpg │ ├── output_earth_250spp.jpg │ ├── output_final_10000spp.jpg │ ├── output_final_100spp.jpg │ ├── output_light_250spp.jpg │ ├── output_noises_200spp.jpg │ └── raytracing_collage.jpg ├── deps ├── glm │ ├── common.hpp │ ├── detail │ │ ├── _features.hpp │ │ ├── _fixes.hpp │ │ ├── _noise.hpp │ │ ├── _swizzle.hpp │ │ ├── _swizzle_func.hpp │ │ ├── _vectorize.hpp │ │ ├── compute_vector_relational.hpp │ │ ├── dummy.cpp │ │ ├── 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_gentype.hpp │ │ ├── type_gentype.inl │ │ ├── type_half.hpp │ │ ├── type_half.inl │ │ ├── type_int.hpp │ │ ├── type_mat.hpp │ │ ├── type_mat.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_vec.hpp │ │ ├── type_vec.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 │ │ ├── vec1.hpp │ │ ├── vec1.inl │ │ ├── vector_relational.hpp │ │ └── vector_relational.inl │ ├── fwd.hpp │ ├── geometric.hpp │ ├── glm.hpp │ ├── gtc │ │ ├── bitfield.hpp │ │ ├── bitfield.inl │ │ ├── color_space.hpp │ │ ├── color_space.inl │ │ ├── constants.hpp │ │ ├── constants.inl │ │ ├── epsilon.hpp │ │ ├── epsilon.inl │ │ ├── integer.hpp │ │ ├── integer.inl │ │ ├── matrix_access.hpp │ │ ├── matrix_access.inl │ │ ├── matrix_integer.hpp │ │ ├── matrix_inverse.hpp │ │ ├── matrix_inverse.inl │ │ ├── matrix_transform.hpp │ │ ├── matrix_transform.inl │ │ ├── noise.hpp │ │ ├── noise.inl │ │ ├── packing.hpp │ │ ├── packing.inl │ │ ├── quaternion.hpp │ │ ├── quaternion.inl │ │ ├── quaternion_simd.inl │ │ ├── random.hpp │ │ ├── random.inl │ │ ├── reciprocal.hpp │ │ ├── reciprocal.inl │ │ ├── round.hpp │ │ ├── round.inl │ │ ├── type_aligned.hpp │ │ ├── type_precision.hpp │ │ ├── type_precision.inl │ │ ├── type_ptr.hpp │ │ ├── type_ptr.inl │ │ ├── ulp.hpp │ │ ├── ulp.inl │ │ ├── vec1.hpp │ │ └── vec1.inl │ ├── 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 │ │ ├── euler_angles.hpp │ │ ├── euler_angles.inl │ │ ├── extend.hpp │ │ ├── extend.inl │ │ ├── extended_min_max.hpp │ │ ├── extended_min_max.inl │ │ ├── exterior_product.hpp │ │ ├── exterior_product.inl │ │ ├── fast_exponential.hpp │ │ ├── fast_exponential.inl │ │ ├── fast_square_root.hpp │ │ ├── fast_square_root.inl │ │ ├── fast_trigonometry.hpp │ │ ├── fast_trigonometry.inl │ │ ├── float_notmalize.inl │ │ ├── functions.hpp │ │ ├── functions.inl │ │ ├── gradient_paint.hpp │ │ ├── gradient_paint.inl │ │ ├── handed_coordinate_space.hpp │ │ ├── handed_coordinate_space.inl │ │ ├── hash.hpp │ │ ├── hash.inl │ │ ├── integer.hpp │ │ ├── integer.inl │ │ ├── intersect.hpp │ │ ├── intersect.inl │ │ ├── io.hpp │ │ ├── io.inl │ │ ├── log_base.hpp │ │ ├── log_base.inl │ │ ├── matrix_cross_product.hpp │ │ ├── matrix_cross_product.inl │ │ ├── matrix_decompose.hpp │ │ ├── matrix_decompose.inl │ │ ├── matrix_factorisation.hpp │ │ ├── matrix_factorisation.inl │ │ ├── matrix_interpolation.hpp │ │ ├── matrix_interpolation.inl │ │ ├── matrix_major_storage.hpp │ │ ├── matrix_major_storage.inl │ │ ├── matrix_operation.hpp │ │ ├── matrix_operation.inl │ │ ├── matrix_query.hpp │ │ ├── matrix_query.inl │ │ ├── matrix_transform_2d.hpp │ │ ├── matrix_transform_2d.inl │ │ ├── mixed_product.hpp │ │ ├── mixed_product.inl │ │ ├── norm.hpp │ │ ├── norm.inl │ │ ├── normal.hpp │ │ ├── normal.inl │ │ ├── normalize_dot.hpp │ │ ├── normalize_dot.inl │ │ ├── number_precision.hpp │ │ ├── number_precision.inl │ │ ├── optimum_pow.hpp │ │ ├── optimum_pow.inl │ │ ├── orthonormalize.hpp │ │ ├── orthonormalize.inl │ │ ├── perpendicular.hpp │ │ ├── perpendicular.inl │ │ ├── polar_coordinates.hpp │ │ ├── polar_coordinates.inl │ │ ├── projection.hpp │ │ ├── projection.inl │ │ ├── quaternion.hpp │ │ ├── quaternion.inl │ │ ├── range.hpp │ │ ├── raw_data.hpp │ │ ├── raw_data.inl │ │ ├── rotate_normalized_axis.hpp │ │ ├── rotate_normalized_axis.inl │ │ ├── rotate_vector.hpp │ │ ├── rotate_vector.inl │ │ ├── scalar_multiplication.hpp │ │ ├── scalar_relational.hpp │ │ ├── scalar_relational.inl │ │ ├── spline.hpp │ │ ├── spline.inl │ │ ├── std_based_type.hpp │ │ ├── std_based_type.inl │ │ ├── string_cast.hpp │ │ ├── string_cast.inl │ │ ├── texture.hpp │ │ ├── texture.inl │ │ ├── transform.hpp │ │ ├── transform.inl │ │ ├── transform2.hpp │ │ ├── transform2.inl │ │ ├── type_aligned.hpp │ │ ├── type_aligned.inl │ │ ├── type_trait.hpp │ │ ├── type_trait.inl │ │ ├── vec_swizzle.hpp │ │ ├── vector_angle.hpp │ │ ├── vector_angle.inl │ │ ├── vector_query.hpp │ │ ├── vector_query.inl │ │ ├── wrap.hpp │ │ └── wrap.inl │ ├── integer.hpp │ ├── mat2x2.hpp │ ├── mat2x3.hpp │ ├── mat2x4.hpp │ ├── mat3x2.hpp │ ├── mat3x3.hpp │ ├── mat3x4.hpp │ ├── mat4x2.hpp │ ├── mat4x3.hpp │ ├── mat4x4.hpp │ ├── matrix.hpp │ ├── packing.hpp │ ├── simd │ │ ├── common.h │ │ ├── exponential.h │ │ ├── geometric.h │ │ ├── integer.h │ │ ├── matrix.h │ │ ├── packing.h │ │ ├── platform.h │ │ ├── trigonometric.h │ │ └── vector_relational.h │ ├── trigonometric.hpp │ ├── vec2.hpp │ ├── vec3.hpp │ ├── vec4.hpp │ └── vector_relational.hpp └── stb │ └── stb_image.h ├── examples └── dev │ ├── main.cpp │ └── main.h ├── include ├── core │ ├── application.h │ └── types.h ├── materials │ ├── material.h │ └── texture.h ├── objects │ ├── aabb.h │ ├── box.h │ ├── bvh.h │ ├── hitable.h │ ├── objects.h │ ├── rect.h │ ├── sphere.h │ └── volume.h ├── renderer │ ├── camera.h │ ├── ray.h │ ├── renderer.h │ └── scene.h └── utils │ ├── bitmap.h │ └── perlin.h ├── project ├── genie.lua └── vs2017 │ ├── dev.vcxproj │ ├── dev.vcxproj.filters │ ├── dev.vcxproj.user │ ├── vxt-Raytracing.sln │ ├── vxt.vcxproj │ ├── vxt.vcxproj.filters │ └── vxt.vcxproj.user ├── src ├── core │ └── application.cpp ├── materials │ ├── material.cpp │ └── texture.cpp ├── objects │ ├── aabb.cpp │ ├── box.cpp │ ├── bvh.cpp │ ├── hitable.cpp │ ├── rect.cpp │ ├── sphere.cpp │ └── volume.cpp ├── renderer │ ├── camera.cpp │ ├── renderer.cpp │ └── scene.cpp └── utils │ ├── bitmap.cpp │ └── perlin.cpp └── tools └── genie.exe /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2018 Víctor Ávila 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ![Samples](/assets/textures/readme/raytracing_collage.jpg) 2 | 3 | _version 0.2.1_ 4 | 5 | # What is vxt? 6 | 7 | __vxt__ is a CPU based multithreaded path tracing renderer written in C++, based on the book Ray Tracing the Next Week by Peter Shirley. The purpose of this project is purely academic as this is my first contact with path tracing techniques! So far so fun :^) 8 | 9 | # Features 10 | 11 | - Multithreaded Tiled Rendering in CPU. 12 | - Creation of Image Previews in the process. 13 | - Objects: Sphere, Box, Axis Aligned Plane, Volume, AABB (all capable of being Translated and Rotated). 14 | - Bounding Volume Hierarchy Acceleration Structure. 15 | - Materials: Lambertian, Metal, Glass, Isotropic (Fog/Smoke), Diffuse Light. 16 | - Textures (used in all materials): Image Based, Noise, Custom. 17 | - Realistic Camera: Depth of Field, Motion Blur. 18 | 19 | 20 | # Building 21 | 22 | _[A vs2017 Solution is provided by default]_ 23 | 24 | This project uses [GENie.lua](https://github.com/bkaradzic/GENie) to create the project solution. Open a CMD in the root directory and execute the following commands to re-create a solution: 25 | 26 | cd project 27 | ..\tools\genie [parameters] 28 | 29 | The solution will be located in _project/vs/vxt-Raytracer.sln_. 30 | 31 | # API 32 | 33 | ```c++ 34 | #include "main.h" 35 | #include "../../include/renderer/renderer.h" 36 | 37 | VXR_DEFINE_APP_MAIN(vxt::Main) 38 | 39 | namespace vxt 40 | { 41 | 42 | void Main::init() 43 | { 44 | constexpr uint32 width = 400; 45 | constexpr uint32 height = 400; 46 | constexpr uint32 samples_per_pixel = 500; 47 | constexpr uint32 num_threads = 8; 48 | 49 | // Note: Use Background for lit scenes, and GradientBackground for unlit scenes! 50 | Renderer renderer(width, height, samples_per_pixel); 51 | renderer.render(new CornellBoxScene(), 52 | new Background(), 53 | CornellBoxScene::camera(width, height), 54 | "output.bmp", num_threads); 55 | 56 | exit_ = true; 57 | Application::init(); 58 | } 59 | 60 | } /* end of vxt namespace */ 61 | ``` 62 | 63 | # Dependencies 64 | 65 | - [glm](https://github.com/g-truc/glm) 66 | - [stb_image.h](https://github.com/nothings/stb) 67 | 68 | # [MIT License](/LICENSE) 69 | 70 | # Contact 71 | 72 | Mail: victorap97@gmail.com 73 | 74 | Twitter: https://twitter.com/97torvic 75 | 76 | Web/Blog/Portfolio: https://avilapa.github.io/portfolio 77 | 78 | # Gallery 79 | 80 | ![Final](/assets/textures/readme/output_final_10000spp.jpg) 81 | ![Cornell](/assets/textures/readme/output_cornell_smoke_scene_500spp.jpg) 82 | ![Lights](/assets/textures/readme/output_light_250spp.jpg) 83 | ![Random](/assets/textures/readme/output_final_100spp.jpg) 84 | ![Earth](/assets/textures/readme/output_earth_250spp.jpg) 85 | ![Reflections](/assets/textures/readme/output_ch08_1000spp.jpg) 86 | ![Noise](/assets/textures/readme/output_noises_200spp.jpg) 87 | 88 | 89 | -------------------------------------------------------------------------------- /assets/textures/earth_map.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/assets/textures/earth_map.jpg -------------------------------------------------------------------------------- /assets/textures/readme/output_ch08_1000spp.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/assets/textures/readme/output_ch08_1000spp.jpg -------------------------------------------------------------------------------- /assets/textures/readme/output_cornell_smoke_scene_500spp.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/assets/textures/readme/output_cornell_smoke_scene_500spp.jpg -------------------------------------------------------------------------------- /assets/textures/readme/output_earth_250spp.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/assets/textures/readme/output_earth_250spp.jpg -------------------------------------------------------------------------------- /assets/textures/readme/output_final_10000spp.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/assets/textures/readme/output_final_10000spp.jpg -------------------------------------------------------------------------------- /assets/textures/readme/output_final_100spp.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/assets/textures/readme/output_final_100spp.jpg -------------------------------------------------------------------------------- /assets/textures/readme/output_light_250spp.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/assets/textures/readme/output_light_250spp.jpg -------------------------------------------------------------------------------- /assets/textures/readme/output_noises_200spp.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/assets/textures/readme/output_noises_200spp.jpg -------------------------------------------------------------------------------- /assets/textures/readme/raytracing_collage.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/assets/textures/readme/raytracing_collage.jpg -------------------------------------------------------------------------------- /deps/glm/detail/_fixes.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/_fixes.hpp 3 | 4 | #include 5 | 6 | //! Workaround for compatibility with other libraries 7 | #ifdef max 8 | #undef max 9 | #endif 10 | 11 | //! Workaround for compatibility with other libraries 12 | #ifdef min 13 | #undef min 14 | #endif 15 | 16 | //! Workaround for Android 17 | #ifdef isnan 18 | #undef isnan 19 | #endif 20 | 21 | //! Workaround for Android 22 | #ifdef isinf 23 | #undef isinf 24 | #endif 25 | 26 | //! Workaround for Chrone Native Client 27 | #ifdef log2 28 | #undef log2 29 | #endif 30 | 31 | -------------------------------------------------------------------------------- /deps/glm/detail/_noise.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/_noise.hpp 3 | 4 | #pragma once 5 | 6 | #include "../vec2.hpp" 7 | #include "../vec3.hpp" 8 | #include "../vec4.hpp" 9 | #include "../common.hpp" 10 | 11 | namespace glm{ 12 | namespace detail 13 | { 14 | template 15 | GLM_FUNC_QUALIFIER T mod289(T const& x) 16 | { 17 | return x - floor(x * (static_cast(1.0) / static_cast(289.0))) * static_cast(289.0); 18 | } 19 | 20 | template 21 | GLM_FUNC_QUALIFIER T permute(T const& x) 22 | { 23 | return mod289(((x * static_cast(34)) + static_cast(1)) * x); 24 | } 25 | 26 | template 27 | GLM_FUNC_QUALIFIER vec<2, T, Q> permute(vec<2, T, Q> const& x) 28 | { 29 | return mod289(((x * static_cast(34)) + static_cast(1)) * x); 30 | } 31 | 32 | template 33 | GLM_FUNC_QUALIFIER vec<3, T, Q> permute(vec<3, T, Q> const& x) 34 | { 35 | return mod289(((x * static_cast(34)) + static_cast(1)) * x); 36 | } 37 | 38 | template 39 | GLM_FUNC_QUALIFIER vec<4, T, Q> permute(vec<4, T, Q> const& x) 40 | { 41 | return mod289(((x * static_cast(34)) + static_cast(1)) * x); 42 | } 43 | 44 | template 45 | GLM_FUNC_QUALIFIER T taylorInvSqrt(T const& r) 46 | { 47 | return T(1.79284291400159) - T(0.85373472095314) * r; 48 | } 49 | 50 | template 51 | GLM_FUNC_QUALIFIER vec<2, T, Q> taylorInvSqrt(vec<2, T, Q> const& r) 52 | { 53 | return T(1.79284291400159) - T(0.85373472095314) * r; 54 | } 55 | 56 | template 57 | GLM_FUNC_QUALIFIER vec<3, T, Q> taylorInvSqrt(vec<3, T, Q> const& r) 58 | { 59 | return T(1.79284291400159) - T(0.85373472095314) * r; 60 | } 61 | 62 | template 63 | GLM_FUNC_QUALIFIER vec<4, T, Q> taylorInvSqrt(vec<4, T, Q> const& r) 64 | { 65 | return T(1.79284291400159) - T(0.85373472095314) * r; 66 | } 67 | 68 | template 69 | GLM_FUNC_QUALIFIER vec<2, T, Q> fade(vec<2, T, Q> const& t) 70 | { 71 | return (t * t * t) * (t * (t * T(6) - T(15)) + T(10)); 72 | } 73 | 74 | template 75 | GLM_FUNC_QUALIFIER vec<3, T, Q> fade(vec<3, T, Q> const& t) 76 | { 77 | return (t * t * t) * (t * (t * T(6) - T(15)) + T(10)); 78 | } 79 | 80 | template 81 | GLM_FUNC_QUALIFIER vec<4, T, Q> fade(vec<4, T, Q> const& t) 82 | { 83 | return (t * t * t) * (t * (t * T(6) - T(15)) + T(10)); 84 | } 85 | }//namespace detail 86 | }//namespace glm 87 | 88 | -------------------------------------------------------------------------------- /deps/glm/detail/compute_vector_relational.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "setup.hpp" 4 | #include 5 | #include 6 | 7 | namespace glm{ 8 | namespace detail 9 | { 10 | template ::is_iec559> 11 | struct compute_equal 12 | { 13 | GLM_FUNC_QUALIFIER 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 static bool call(T a, T b) 23 | { 24 | return std::memcmp(&a, &b, sizeof(T)) == 0; 25 | } 26 | }; 27 | }//namespace detail 28 | }//namespace glm 29 | -------------------------------------------------------------------------------- /deps/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 | template<> 23 | struct compute_sqrt<4, float, aligned_lowp, true> 24 | { 25 | GLM_FUNC_QUALIFIER static vec<4, float, aligned_lowp> call(vec<4, float, aligned_lowp> const& v) 26 | { 27 | vec<4, float, aligned_lowp> Result; 28 | Result.data = glm_vec4_sqrt_lowp(v.data); 29 | return Result; 30 | } 31 | }; 32 | }//namespace detail 33 | }//namespace glm 34 | 35 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 36 | -------------------------------------------------------------------------------- /deps/glm/detail/func_geometric_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/func_geometric_simd.inl 3 | 4 | #include "../simd/geometric.h" 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | namespace glm{ 9 | namespace detail 10 | { 11 | template 12 | struct compute_length<4, float, Q, true> 13 | { 14 | GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& v) 15 | { 16 | return _mm_cvtss_f32(glm_vec4_length(v.data)); 17 | } 18 | }; 19 | 20 | template 21 | struct compute_distance<4, float, Q, true> 22 | { 23 | GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& p0, vec<4, float, Q> const& p1) 24 | { 25 | return _mm_cvtss_f32(glm_vec4_distance(p0.data, p1.data)); 26 | } 27 | }; 28 | 29 | template 30 | struct compute_dot, float, true> 31 | { 32 | GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& x, vec<4, float, Q> const& y) 33 | { 34 | return _mm_cvtss_f32(glm_vec1_dot(x.data, y.data)); 35 | } 36 | }; 37 | 38 | template 39 | struct compute_cross 40 | { 41 | GLM_FUNC_QUALIFIER static vec<3, float, Q> call(vec<3, float, Q> const& a, vec<3, float, Q> const& b) 42 | { 43 | __m128 const set0 = _mm_set_ps(0.0f, a.z, a.y, a.x); 44 | __m128 const set1 = _mm_set_ps(0.0f, b.z, b.y, b.x); 45 | __m128 const xpd0 = glm_vec4_cross(set0, set1); 46 | 47 | vec<4, float, Q> Result; 48 | Result.data = xpd0; 49 | return vec<3, float, Q>(Result); 50 | } 51 | }; 52 | 53 | template 54 | struct compute_normalize<4, float, Q, true> 55 | { 56 | GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v) 57 | { 58 | vec<4, float, Q> Result; 59 | Result.data = glm_vec4_normalize(v.data); 60 | return Result; 61 | } 62 | }; 63 | 64 | template 65 | struct compute_faceforward<4, float, Q, true> 66 | { 67 | GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& N, vec<4, float, Q> const& I, vec<4, float, Q> const& Nref) 68 | { 69 | vec<4, float, Q> Result; 70 | Result.data = glm_vec4_faceforward(N.data, I.data, Nref.data); 71 | return Result; 72 | } 73 | }; 74 | 75 | template 76 | struct compute_reflect<4, float, Q, true> 77 | { 78 | GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& I, vec<4, float, Q> const& N) 79 | { 80 | vec<4, float, Q> Result; 81 | Result.data = glm_vec4_reflect(I.data, N.data); 82 | return Result; 83 | } 84 | }; 85 | 86 | template 87 | struct compute_refract<4, float, Q, true> 88 | { 89 | GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& I, vec<4, float, Q> const& N, float eta) 90 | { 91 | vec<4, float, Q> Result; 92 | Result.data = glm_vec4_refract(I.data, N.data, _mm_set1_ps(eta)); 93 | return Result; 94 | } 95 | }; 96 | }//namespace detail 97 | }//namespace glm 98 | 99 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 100 | -------------------------------------------------------------------------------- /deps/glm/detail/func_integer_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/func_integer_simd.inl 3 | 4 | #include "../simd/integer.h" 5 | 6 | #if GLM_ARCH & GLM_ARCH_SSE2_BIT 7 | 8 | namespace glm{ 9 | namespace detail 10 | { 11 | template 12 | struct compute_bitfieldReverseStep<4, uint32, Q, true, true> 13 | { 14 | GLM_FUNC_QUALIFIER static vec<4, uint32, Q> call(vec<4, uint32, Q> const& v, uint32 Mask, uint32 Shift) 15 | { 16 | __m128i const set0 = v.data; 17 | 18 | __m128i const set1 = _mm_set1_epi32(static_cast(Mask)); 19 | __m128i const and1 = _mm_and_si128(set0, set1); 20 | __m128i const sft1 = _mm_slli_epi32(and1, Shift); 21 | 22 | __m128i const set2 = _mm_andnot_si128(set0, _mm_set1_epi32(-1)); 23 | __m128i const and2 = _mm_and_si128(set0, set2); 24 | __m128i const sft2 = _mm_srai_epi32(and2, Shift); 25 | 26 | __m128i const or0 = _mm_or_si128(sft1, sft2); 27 | 28 | return or0; 29 | } 30 | }; 31 | 32 | template 33 | struct compute_bitfieldBitCountStep<4, uint32, Q, true, true> 34 | { 35 | GLM_FUNC_QUALIFIER static vec<4, uint32, Q> call(vec<4, uint32, Q> const& v, uint32 Mask, uint32 Shift) 36 | { 37 | __m128i const set0 = v.data; 38 | 39 | __m128i const set1 = _mm_set1_epi32(static_cast(Mask)); 40 | __m128i const and0 = _mm_and_si128(set0, set1); 41 | __m128i const sft0 = _mm_slli_epi32(set0, Shift); 42 | __m128i const and1 = _mm_and_si128(sft0, set1); 43 | __m128i const add0 = _mm_add_epi32(and0, and1); 44 | 45 | return add0; 46 | } 47 | }; 48 | }//namespace detail 49 | 50 | # if GLM_ARCH & GLM_ARCH_AVX_BIT 51 | template<> 52 | GLM_FUNC_QUALIFIER int bitCount(uint32 x) 53 | { 54 | return _mm_popcnt_u32(x); 55 | } 56 | 57 | # if(GLM_MODEL == GLM_MODEL_64) 58 | template<> 59 | GLM_FUNC_QUALIFIER int bitCount(uint64 x) 60 | { 61 | return static_cast(_mm_popcnt_u64(x)); 62 | } 63 | # endif//GLM_MODEL 64 | # endif//GLM_ARCH 65 | 66 | }//namespace glm 67 | 68 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 69 | -------------------------------------------------------------------------------- /deps/glm/detail/func_packing_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/func_packing_simd.inl 3 | 4 | namespace glm{ 5 | namespace detail 6 | { 7 | 8 | }//namespace detail 9 | }//namespace glm 10 | -------------------------------------------------------------------------------- /deps/glm/detail/func_trigonometric_simd.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/deps/glm/detail/func_trigonometric_simd.inl -------------------------------------------------------------------------------- /deps/glm/detail/func_vector_relational_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/func_vector_relational_simd.inl 3 | 4 | namespace glm{ 5 | namespace detail 6 | { 7 | 8 | }//namespace detail 9 | }//namespace glm 10 | -------------------------------------------------------------------------------- /deps/glm/detail/qualifier.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/qualifier.hpp 3 | 4 | #pragma once 5 | 6 | #include "setup.hpp" 7 | 8 | namespace glm 9 | { 10 | /// Qualify GLM types in term of alignment (packed, aligned) and precision in term of ULPs (lowp, mediump, highp) 11 | enum qualifier 12 | { 13 | packed_highp, ///< Typed data is tightly packed in memory and operations are executed with high precision in term of ULPs 14 | packed_mediump, ///< Typed data is tightly packed in memory and operations are executed with medium precision in term of ULPs for higher performance 15 | packed_lowp, ///< Typed data is tightly packed in memory and operations are executed with low precision in term of ULPs to maximize performance 16 | 17 | # if GLM_HAS_ALIGNED_TYPE 18 | aligned_highp, ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs 19 | aligned_mediump, ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs for higher performance 20 | aligned_lowp, // ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs to maximize performance 21 | aligned = aligned_highp, ///< By default aligned qualifier is also high precision 22 | # endif 23 | 24 | highp = packed_highp, ///< By default highp qualifier is also packed 25 | mediump = packed_mediump, ///< By default mediump qualifier is also packed 26 | lowp = packed_lowp, ///< By default lowp qualifier is also packed 27 | packed = packed_highp, ///< By default packed qualifier is also high precision 28 | 29 | # if GLM_HAS_ALIGNED_TYPE && defined(GLM_FORCE_ALIGNED) 30 | defaultp = aligned_highp 31 | # else 32 | defaultp = highp 33 | # endif 34 | }; 35 | 36 | template struct vec; 37 | template struct mat; 38 | 39 | namespace detail 40 | { 41 | template 42 | struct is_aligned 43 | { 44 | static const bool value = false; 45 | }; 46 | 47 | # if GLM_HAS_ALIGNED_TYPE 48 | template<> 49 | struct is_aligned 50 | { 51 | static const bool value = true; 52 | }; 53 | 54 | template<> 55 | struct is_aligned 56 | { 57 | static const bool value = true; 58 | }; 59 | 60 | template<> 61 | struct is_aligned 62 | { 63 | static const bool value = true; 64 | }; 65 | # endif 66 | }//namespace detail 67 | }//namespace glm 68 | -------------------------------------------------------------------------------- /deps/glm/detail/type_float.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/type_float.hpp 3 | 4 | #pragma once 5 | 6 | #include "setup.hpp" 7 | 8 | namespace glm{ 9 | namespace detail 10 | { 11 | typedef float float32; 12 | 13 | # ifndef GLM_FORCE_SINGLE_ONLY 14 | typedef double float64; 15 | # endif//GLM_FORCE_SINGLE_ONLY 16 | }//namespace detail 17 | 18 | typedef float lowp_float_t; 19 | typedef float mediump_float_t; 20 | typedef double highp_float_t; 21 | 22 | /// @addtogroup core_precision 23 | /// @{ 24 | 25 | /// Low qualifier floating-point numbers. 26 | /// There is no guarantee on the actual qualifier. 27 | /// 28 | /// @see GLSL 4.20.8 specification, section 4.1.4 Floats 29 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 30 | typedef lowp_float_t lowp_float; 31 | 32 | /// Medium qualifier floating-point numbers. 33 | /// There is no guarantee on the actual qualifier. 34 | /// 35 | /// @see GLSL 4.20.8 specification, section 4.1.4 Floats 36 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 37 | typedef mediump_float_t mediump_float; 38 | 39 | /// High qualifier floating-point numbers. 40 | /// There is no guarantee on the actual qualifier. 41 | /// 42 | /// @see GLSL 4.20.8 specification, section 4.1.4 Floats 43 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 44 | typedef highp_float_t highp_float; 45 | 46 | #if(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT)) 47 | typedef mediump_float float_t; 48 | #elif(defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT)) 49 | typedef highp_float float_t; 50 | #elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT)) 51 | typedef mediump_float float_t; 52 | #elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && defined(GLM_PRECISION_LOWP_FLOAT)) 53 | typedef lowp_float float_t; 54 | #else 55 | # error "GLM error: multiple default precision requested for floating-point types" 56 | #endif 57 | 58 | typedef float float32; 59 | 60 | # ifndef GLM_FORCE_SINGLE_ONLY 61 | typedef double float64; 62 | # endif//GLM_FORCE_SINGLE_ONLY 63 | 64 | //////////////////// 65 | // check type sizes 66 | #ifndef GLM_STATIC_ASSERT_NULL 67 | GLM_STATIC_ASSERT(sizeof(glm::float32) == 4, "float32 size isn't 4 bytes on this platform"); 68 | # ifndef GLM_FORCE_SINGLE_ONLY 69 | GLM_STATIC_ASSERT(sizeof(glm::float64) == 8, "float64 size isn't 8 bytes on this platform"); 70 | # endif//GLM_FORCE_SINGLE_ONLY 71 | #endif//GLM_STATIC_ASSERT_NULL 72 | 73 | /// @} 74 | 75 | }//namespace glm 76 | -------------------------------------------------------------------------------- /deps/glm/detail/type_half.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/type_half.hpp 3 | 4 | #pragma once 5 | 6 | #include "setup.hpp" 7 | 8 | namespace glm{ 9 | namespace detail 10 | { 11 | typedef short hdata; 12 | 13 | GLM_FUNC_DECL float toFloat32(hdata value); 14 | GLM_FUNC_DECL hdata toFloat16(float const& value); 15 | 16 | }//namespace detail 17 | }//namespace glm 18 | 19 | #include "type_half.inl" 20 | -------------------------------------------------------------------------------- /deps/glm/detail/type_mat.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/type_mat.inl 3 | 4 | -------------------------------------------------------------------------------- /deps/glm/detail/type_mat4x4_simd.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/type_mat4x4_sse2.inl 3 | 4 | namespace glm 5 | { 6 | 7 | }//namespace glm 8 | -------------------------------------------------------------------------------- /deps/glm/detail/type_vec.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/type_vec.inl 3 | -------------------------------------------------------------------------------- /deps/glm/detail/type_vec1.hpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/deps/glm/detail/type_vec1.hpp -------------------------------------------------------------------------------- /deps/glm/ext/vec1.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/deps/glm/ext/vec1.inl -------------------------------------------------------------------------------- /deps/glm/ext/vector_relational.inl: -------------------------------------------------------------------------------- 1 | /// @ref ext_vector_relational 2 | /// @file glm/ext/vector_relational.inl 3 | 4 | // Dependency: 5 | #include "../vector_relational.hpp" 6 | #include "../common.hpp" 7 | #include "../detail/type_vec.hpp" 8 | 9 | namespace glm 10 | { 11 | template 12 | GLM_FUNC_QUALIFIER bool equal(genType const& x, genType const& y, genType const& epsilon) 13 | { 14 | return abs(x - y) < epsilon; 15 | } 16 | 17 | template 18 | GLM_FUNC_QUALIFIER vec equal(vec const& x, vec const& y, T const& epsilon) 19 | { 20 | return lessThan(abs(x - y), vec(epsilon)); 21 | } 22 | 23 | template 24 | GLM_FUNC_QUALIFIER vec equal(vec const& x, vec const& y, vec const& epsilon) 25 | { 26 | return lessThan(abs(x - y), epsilon); 27 | } 28 | 29 | template 30 | GLM_FUNC_QUALIFIER bool notEqual(genType const& x, genType const& y, genType const& epsilon) 31 | { 32 | return abs(x - y) >= epsilon; 33 | } 34 | 35 | template 36 | GLM_FUNC_QUALIFIER vec notEqual(vec const& x, vec const& y, T const& epsilon) 37 | { 38 | return greaterThanEqual(abs(x - y), vec(epsilon)); 39 | } 40 | 41 | template 42 | GLM_FUNC_QUALIFIER vec notEqual(vec const& x, vec const& y, vec const& epsilon) 43 | { 44 | return greaterThanEqual(abs(x - y), epsilon); 45 | } 46 | 47 | template 48 | GLM_FUNC_QUALIFIER vec openBounded(vec const& Value, vec const& Min, vec const& Max) 49 | { 50 | return greaterThan(Value, Min) && lessThan(Value, Max); 51 | } 52 | 53 | template 54 | GLM_FUNC_QUALIFIER vec closeBounded(vec const& Value, vec const& Min, vec const& Max) 55 | { 56 | return greaterThanEqual(Value, Min) && lessThanEqual(Value, Max); 57 | } 58 | }//namespace glm 59 | -------------------------------------------------------------------------------- /deps/glm/gtc/color_space.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_color_space 2 | /// @file glm/gtc/color_space.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_color_space (dependence) 6 | /// 7 | /// @defgroup gtc_color_space GLM_GTC_color_space 8 | /// @ingroup gtc 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// 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 "../exponential.hpp" 20 | #include "../vec3.hpp" 21 | #include "../vec4.hpp" 22 | #include 23 | 24 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 25 | # pragma message("GLM: GLM_GTC_color_space extension included") 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtc_color_space 31 | /// @{ 32 | 33 | /// Convert a linear color to sRGB color using a standard gamma correction. 34 | /// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb 35 | template 36 | GLM_FUNC_DECL vec convertLinearToSRGB(vec const& ColorLinear); 37 | 38 | /// Convert a linear color to sRGB color using a custom gamma correction. 39 | /// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb 40 | template 41 | GLM_FUNC_DECL vec convertLinearToSRGB(vec const& ColorLinear, T Gamma); 42 | 43 | /// Convert a sRGB color to linear color using a standard gamma correction. 44 | /// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb 45 | template 46 | GLM_FUNC_DECL vec convertSRGBToLinear(vec const& ColorSRGB); 47 | 48 | /// Convert a sRGB color to linear color using a custom gamma correction. 49 | // IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb 50 | template 51 | GLM_FUNC_DECL vec convertSRGBToLinear(vec const& ColorSRGB, T Gamma); 52 | 53 | /// @} 54 | } //namespace glm 55 | 56 | #include "color_space.inl" 57 | -------------------------------------------------------------------------------- /deps/glm/gtc/epsilon.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_epsilon 2 | /// @file glm/gtc/epsilon.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_quaternion (dependence) 6 | /// 7 | /// @defgroup gtc_epsilon GLM_GTC_epsilon 8 | /// @ingroup gtc 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Comparison functions for a user defined epsilon values. 13 | 14 | #pragma once 15 | 16 | // Dependencies 17 | #include "../detail/setup.hpp" 18 | #include "../detail/qualifier.hpp" 19 | 20 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 21 | # pragma message("GLM: GLM_GTC_epsilon extension included") 22 | #endif 23 | 24 | namespace glm 25 | { 26 | /// @addtogroup gtc_epsilon 27 | /// @{ 28 | 29 | /// Returns the component-wise comparison of |x - y| < epsilon. 30 | /// True if this expression is satisfied. 31 | /// 32 | /// @see gtc_epsilon 33 | template 34 | GLM_FUNC_DECL vec epsilonEqual(vec const& x, vec const& y, T const& epsilon); 35 | 36 | /// Returns the component-wise comparison of |x - y| < epsilon. 37 | /// True if this expression is satisfied. 38 | /// 39 | /// @see gtc_epsilon 40 | template 41 | GLM_FUNC_DECL bool epsilonEqual(genType const& x, genType const& y, genType const& epsilon); 42 | 43 | /// Returns the component-wise comparison of |x - y| < epsilon. 44 | /// True if this expression is not satisfied. 45 | /// 46 | /// @see gtc_epsilon 47 | template 48 | GLM_FUNC_DECL vec epsilonNotEqual(vec const& x, vec const& y, T const& epsilon); 49 | 50 | /// Returns the component-wise comparison of |x - y| >= epsilon. 51 | /// True if this expression is not satisfied. 52 | /// 53 | /// @see gtc_epsilon 54 | template 55 | GLM_FUNC_DECL bool epsilonNotEqual(genType const& x, genType const& y, genType const& epsilon); 56 | 57 | /// @} 58 | }//namespace glm 59 | 60 | #include "epsilon.inl" 61 | -------------------------------------------------------------------------------- /deps/glm/gtc/epsilon.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_epsilon 2 | /// @file glm/gtc/epsilon.inl 3 | 4 | // Dependency: 5 | #include "quaternion.hpp" 6 | #include "../vector_relational.hpp" 7 | #include "../common.hpp" 8 | #include "../detail/type_vec.hpp" 9 | 10 | namespace glm 11 | { 12 | template<> 13 | GLM_FUNC_QUALIFIER bool epsilonEqual 14 | ( 15 | float const& x, 16 | float const& y, 17 | float const& epsilon 18 | ) 19 | { 20 | return abs(x - y) < epsilon; 21 | } 22 | 23 | template<> 24 | GLM_FUNC_QUALIFIER bool epsilonEqual 25 | ( 26 | double const& x, 27 | double const& y, 28 | double const& epsilon 29 | ) 30 | { 31 | return abs(x - y) < epsilon; 32 | } 33 | 34 | template 35 | GLM_FUNC_QUALIFIER vec epsilonEqual(vec const& x, vec const& y, T const& epsilon) 36 | { 37 | return lessThan(abs(x - y), vec(epsilon)); 38 | } 39 | 40 | template 41 | GLM_FUNC_QUALIFIER vec epsilonEqual(vec const& x, vec const& y, vec const& epsilon) 42 | { 43 | return lessThan(abs(x - y), vec(epsilon)); 44 | } 45 | 46 | template<> 47 | GLM_FUNC_QUALIFIER bool epsilonNotEqual(float const& x, float const& y, float const& epsilon) 48 | { 49 | return abs(x - y) >= epsilon; 50 | } 51 | 52 | template<> 53 | GLM_FUNC_QUALIFIER bool epsilonNotEqual(double const& x, double const& y, double const& epsilon) 54 | { 55 | return abs(x - y) >= epsilon; 56 | } 57 | 58 | template 59 | GLM_FUNC_QUALIFIER vec epsilonNotEqual(vec const& x, vec const& y, T const& epsilon) 60 | { 61 | return greaterThanEqual(abs(x - y), vec(epsilon)); 62 | } 63 | 64 | template 65 | GLM_FUNC_QUALIFIER vec epsilonNotEqual(vec const& x, vec const& y, vec const& epsilon) 66 | { 67 | return greaterThanEqual(abs(x - y), vec(epsilon)); 68 | } 69 | 70 | template 71 | GLM_FUNC_QUALIFIER vec<4, bool, Q> epsilonEqual(tquat const& x, tquat const& y, T const& epsilon) 72 | { 73 | vec<4, T, Q> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w); 74 | return lessThan(abs(v), vec<4, T, Q>(epsilon)); 75 | } 76 | 77 | template 78 | GLM_FUNC_QUALIFIER vec<4, bool, Q> epsilonNotEqual(tquat const& x, tquat const& y, T const& epsilon) 79 | { 80 | vec<4, T, Q> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w); 81 | return greaterThanEqual(abs(v), vec<4, T, Q>(epsilon)); 82 | } 83 | }//namespace glm 84 | -------------------------------------------------------------------------------- /deps/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 23 | 24 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 25 | # pragma message("GLM: GLM_GTC_integer extension included") 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtc_integer 31 | /// @{ 32 | 33 | /// Returns the log2 of x for integer values. Can be reliably using to compute mipmap count from the texture size. 34 | /// @see gtc_integer 35 | template 36 | GLM_FUNC_DECL genIUType log2(genIUType x); 37 | 38 | /// Returns a value equal to the nearest integer to x. 39 | /// The fraction 0.5 will round in a direction chosen by the 40 | /// implementation, presumably the direction that is fastest. 41 | /// 42 | /// @param x The values of the argument must be greater or equal to zero. 43 | /// @tparam T floating point scalar types. 44 | /// 45 | /// @see GLSL round man page 46 | /// @see gtc_integer 47 | template 48 | GLM_FUNC_DECL vec iround(vec const& x); 49 | 50 | /// Returns a value equal to the nearest integer to x. 51 | /// The fraction 0.5 will round in a direction chosen by the 52 | /// implementation, presumably the direction that is fastest. 53 | /// 54 | /// @param x The values of the argument must be greater or equal to zero. 55 | /// @tparam T floating point scalar types. 56 | /// 57 | /// @see GLSL round man page 58 | /// @see gtc_integer 59 | template 60 | GLM_FUNC_DECL vec uround(vec const& x); 61 | 62 | /// @} 63 | } //namespace glm 64 | 65 | #include "integer.inl" 66 | -------------------------------------------------------------------------------- /deps/glm/gtc/integer.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_integer 2 | /// @file glm/gtc/integer.inl 3 | 4 | namespace glm{ 5 | namespace detail 6 | { 7 | template 8 | struct compute_log2 9 | { 10 | GLM_FUNC_QUALIFIER static vec call(vec const& v) 11 | { 12 | //Equivalent to return findMSB(vec); but save one function call in ASM with VC 13 | //return findMSB(vec); 14 | return vec(detail::compute_findMSB_vec::call(v)); 15 | } 16 | }; 17 | 18 | # if GLM_HAS_BITSCAN_WINDOWS 19 | template 20 | struct compute_log2<4, int, Q, false, Aligned> 21 | { 22 | GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v) 23 | { 24 | vec<4, int, Q> Result; 25 | _BitScanReverse(reinterpret_cast(&Result.x), v.x); 26 | _BitScanReverse(reinterpret_cast(&Result.y), v.y); 27 | _BitScanReverse(reinterpret_cast(&Result.z), v.z); 28 | _BitScanReverse(reinterpret_cast(&Result.w), v.w); 29 | return Result; 30 | } 31 | }; 32 | # endif//GLM_HAS_BITSCAN_WINDOWS 33 | }//namespace detail 34 | template 35 | GLM_FUNC_QUALIFIER int iround(genType x) 36 | { 37 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'iround' only accept floating-point inputs"); 38 | assert(static_cast(0.0) <= x); 39 | 40 | return static_cast(x + static_cast(0.5)); 41 | } 42 | 43 | template 44 | GLM_FUNC_QUALIFIER vec iround(vec const& x) 45 | { 46 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'iround' only accept floating-point inputs"); 47 | assert(all(lessThanEqual(vec(0), x))); 48 | 49 | return vec(x + static_cast(0.5)); 50 | } 51 | 52 | template 53 | GLM_FUNC_QUALIFIER uint uround(genType x) 54 | { 55 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'uround' only accept floating-point inputs"); 56 | assert(static_cast(0.0) <= x); 57 | 58 | return static_cast(x + static_cast(0.5)); 59 | } 60 | 61 | template 62 | GLM_FUNC_QUALIFIER vec uround(vec const& x) 63 | { 64 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'uround' only accept floating-point inputs"); 65 | assert(all(lessThanEqual(vec(0), x))); 66 | 67 | return vec(x + static_cast(0.5)); 68 | } 69 | }//namespace glm 70 | -------------------------------------------------------------------------------- /deps/glm/gtc/matrix_access.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_matrix_access 2 | /// @file glm/gtc/matrix_access.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_matrix_access GLM_GTC_matrix_access 7 | /// @ingroup gtc 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines functions to access rows or columns of a matrix easily. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../detail/setup.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_GTC_matrix_access extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | /// @addtogroup gtc_matrix_access 25 | /// @{ 26 | 27 | /// Get a specific row of a matrix. 28 | /// @see gtc_matrix_access 29 | template 30 | GLM_FUNC_DECL typename genType::row_type row( 31 | genType const& m, 32 | length_t index); 33 | 34 | /// Set a specific row to a matrix. 35 | /// @see gtc_matrix_access 36 | template 37 | GLM_FUNC_DECL genType row( 38 | genType const& m, 39 | length_t index, 40 | typename genType::row_type const& x); 41 | 42 | /// Get a specific column of a matrix. 43 | /// @see gtc_matrix_access 44 | template 45 | GLM_FUNC_DECL typename genType::col_type column( 46 | genType const& m, 47 | length_t index); 48 | 49 | /// Set a specific column to a matrix. 50 | /// @see gtc_matrix_access 51 | template 52 | GLM_FUNC_DECL genType column( 53 | genType const& m, 54 | length_t index, 55 | typename genType::col_type const& x); 56 | 57 | /// @} 58 | }//namespace glm 59 | 60 | #include "matrix_access.inl" 61 | -------------------------------------------------------------------------------- /deps/glm/gtc/matrix_access.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_matrix_access 2 | /// @file glm/gtc/matrix_access.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER genType row 8 | ( 9 | genType const& m, 10 | length_t index, 11 | typename genType::row_type const& x 12 | ) 13 | { 14 | assert(index >= 0 && index < m[0].length()); 15 | 16 | genType Result = m; 17 | for(length_t i = 0; i < m.length(); ++i) 18 | Result[i][index] = x[i]; 19 | return Result; 20 | } 21 | 22 | template 23 | GLM_FUNC_QUALIFIER typename genType::row_type row 24 | ( 25 | genType const& m, 26 | length_t index 27 | ) 28 | { 29 | assert(index >= 0 && index < m[0].length()); 30 | 31 | typename genType::row_type Result; 32 | for(length_t i = 0; i < m.length(); ++i) 33 | Result[i] = m[i][index]; 34 | return Result; 35 | } 36 | 37 | template 38 | GLM_FUNC_QUALIFIER genType column 39 | ( 40 | genType const& m, 41 | length_t index, 42 | typename genType::col_type const& x 43 | ) 44 | { 45 | assert(index >= 0 && index < m.length()); 46 | 47 | genType Result = m; 48 | Result[index] = x; 49 | return Result; 50 | } 51 | 52 | template 53 | GLM_FUNC_QUALIFIER typename genType::col_type column 54 | ( 55 | genType const& m, 56 | length_t index 57 | ) 58 | { 59 | assert(index >= 0 && index < m.length()); 60 | 61 | return m[index]; 62 | } 63 | }//namespace glm 64 | -------------------------------------------------------------------------------- /deps/glm/gtc/matrix_inverse.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_matrix_inverse 2 | /// @file glm/gtc/matrix_inverse.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_matrix_inverse GLM_GTC_matrix_inverse 7 | /// @ingroup gtc 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines additional matrix inverting functions. 12 | 13 | #pragma once 14 | 15 | // Dependencies 16 | #include "../detail/setup.hpp" 17 | #include "../matrix.hpp" 18 | #include "../mat2x2.hpp" 19 | #include "../mat3x3.hpp" 20 | #include "../mat4x4.hpp" 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTC_matrix_inverse extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtc_matrix_inverse 29 | /// @{ 30 | 31 | /// Fast matrix inverse for affine matrix. 32 | /// 33 | /// @param m Input matrix to invert. 34 | /// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-qualifier floating point value is highly innacurate. 35 | /// @see gtc_matrix_inverse 36 | template 37 | GLM_FUNC_DECL genType affineInverse(genType const& m); 38 | 39 | /// Compute the inverse transpose of a matrix. 40 | /// 41 | /// @param m Input matrix to invert transpose. 42 | /// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-qualifier floating point value is highly innacurate. 43 | /// @see gtc_matrix_inverse 44 | template 45 | GLM_FUNC_DECL genType inverseTranspose(genType const& m); 46 | 47 | /// @} 48 | }//namespace glm 49 | 50 | #include "matrix_inverse.inl" 51 | -------------------------------------------------------------------------------- /deps/glm/gtc/noise.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_noise 2 | /// @file glm/gtc/noise.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_noise GLM_GTC_noise 7 | /// @ingroup gtc 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Defines 2D, 3D and 4D procedural noise functions 12 | /// Based on the work of Stefan Gustavson and Ashima Arts on "webgl-noise": 13 | /// https://github.com/ashima/webgl-noise 14 | /// Following Stefan Gustavson's paper "Simplex noise demystified": 15 | /// http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf 16 | 17 | #pragma once 18 | 19 | // Dependencies 20 | #include "../detail/setup.hpp" 21 | #include "../detail/qualifier.hpp" 22 | #include "../detail/_noise.hpp" 23 | #include "../geometric.hpp" 24 | #include "../common.hpp" 25 | #include "../vector_relational.hpp" 26 | #include "../vec2.hpp" 27 | #include "../vec3.hpp" 28 | #include "../vec4.hpp" 29 | 30 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 31 | # pragma message("GLM: GLM_GTC_noise extension included") 32 | #endif 33 | 34 | namespace glm 35 | { 36 | /// @addtogroup gtc_noise 37 | /// @{ 38 | 39 | /// Classic perlin noise. 40 | /// @see gtc_noise 41 | template 42 | GLM_FUNC_DECL T perlin( 43 | vec const& p); 44 | 45 | /// Periodic perlin noise. 46 | /// @see gtc_noise 47 | template 48 | GLM_FUNC_DECL T perlin( 49 | vec const& p, 50 | vec const& rep); 51 | 52 | /// Simplex noise. 53 | /// @see gtc_noise 54 | template 55 | GLM_FUNC_DECL T simplex( 56 | vec const& p); 57 | 58 | /// @} 59 | }//namespace glm 60 | 61 | #include "noise.inl" 62 | -------------------------------------------------------------------------------- /deps/glm/gtc/random.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_random 2 | /// @file glm/gtc/random.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_random (extended) 6 | /// 7 | /// @defgroup gtc_random GLM_GTC_random 8 | /// @ingroup gtc 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Generate random number from various distribution methods. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../vec2.hpp" 18 | #include "../vec3.hpp" 19 | 20 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 21 | # pragma message("GLM: GLM_GTC_random extension included") 22 | #endif 23 | 24 | namespace glm 25 | { 26 | /// @addtogroup gtc_random 27 | /// @{ 28 | 29 | /// Generate random numbers in the interval [Min, Max], according a linear distribution 30 | /// 31 | /// @param Min Minimum value included in the sampling 32 | /// @param Max Maximum value included in the sampling 33 | /// @tparam genType Value type. Currently supported: float or double scalars. 34 | /// @see gtc_random 35 | template 36 | GLM_FUNC_DECL genType linearRand(genType Min, genType Max); 37 | 38 | /// Generate random numbers in the interval [Min, Max], according a linear distribution 39 | /// 40 | /// @param Min Minimum value included in the sampling 41 | /// @param Max Maximum value included in the sampling 42 | /// @tparam T Value type. Currently supported: float or double. 43 | /// 44 | /// @see gtc_random 45 | template 46 | GLM_FUNC_DECL vec linearRand(vec const& Min, vec const& Max); 47 | 48 | /// Generate random numbers in the interval [Min, Max], according a gaussian distribution 49 | /// 50 | /// @see gtc_random 51 | template 52 | GLM_FUNC_DECL genType gaussRand(genType Mean, genType Deviation); 53 | 54 | /// Generate a random 2D vector which coordinates are regulary distributed on a circle of a given radius 55 | /// 56 | /// @see gtc_random 57 | template 58 | GLM_FUNC_DECL vec<2, T, defaultp> circularRand(T Radius); 59 | 60 | /// Generate a random 3D vector which coordinates are regulary distributed on a sphere of a given radius 61 | /// 62 | /// @see gtc_random 63 | template 64 | GLM_FUNC_DECL vec<3, T, defaultp> sphericalRand(T Radius); 65 | 66 | /// Generate a random 2D vector which coordinates are regulary distributed within the area of a disk of a given radius 67 | /// 68 | /// @see gtc_random 69 | template 70 | GLM_FUNC_DECL vec<2, T, defaultp> diskRand(T Radius); 71 | 72 | /// Generate a random 3D vector which coordinates are regulary distributed within the volume of a ball of a given radius 73 | /// 74 | /// @see gtc_random 75 | template 76 | GLM_FUNC_DECL vec<3, T, defaultp> ballRand(T Radius); 77 | 78 | /// @} 79 | }//namespace glm 80 | 81 | #include "random.inl" 82 | -------------------------------------------------------------------------------- /deps/glm/gtc/type_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_swizzle 2 | /// @file glm/gtc/swizzle.inl 3 | 4 | namespace glm 5 | { 6 | 7 | } 8 | -------------------------------------------------------------------------------- /deps/glm/gtc/ulp.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtc_ulp 2 | /// @file glm/gtc/ulp.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtc_ulp GLM_GTC_ulp 7 | /// @ingroup gtc 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Allow the measurement of the accuracy of a function against a reference 12 | /// implementation. This extension works on floating-point data and provide results 13 | /// in ULP. 14 | 15 | #pragma once 16 | 17 | // Dependencies 18 | #include "../detail/setup.hpp" 19 | #include "../detail/qualifier.hpp" 20 | #include "../detail/type_int.hpp" 21 | #include "../detail/compute_vector_relational.hpp" 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTC_ulp extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtc_ulp 30 | /// @{ 31 | 32 | /// Return the next ULP value(s) after the input value(s). 33 | /// @see gtc_ulp 34 | template 35 | GLM_FUNC_DECL genType next_float(genType const& x); 36 | 37 | /// Return the previous ULP value(s) before the input value(s). 38 | /// @see gtc_ulp 39 | template 40 | GLM_FUNC_DECL genType prev_float(genType const& x); 41 | 42 | /// Return the value(s) ULP distance after the input value(s). 43 | /// @see gtc_ulp 44 | template 45 | GLM_FUNC_DECL genType next_float(genType const& x, uint const& Distance); 46 | 47 | /// Return the value(s) ULP distance before the input value(s). 48 | /// @see gtc_ulp 49 | template 50 | GLM_FUNC_DECL genType prev_float(genType const& x, uint const& Distance); 51 | 52 | /// Return the distance in the number of ULP between 2 scalars. 53 | /// @see gtc_ulp 54 | template 55 | GLM_FUNC_DECL uint float_distance(T const& x, T const& y); 56 | 57 | /// Return the distance in the number of ULP between 2 vectors. 58 | /// @see gtc_ulp 59 | template 60 | GLM_FUNC_DECL vec<2, uint, Q> float_distance(vec<2, T, Q> const& x, vec<2, T, Q> const& y); 61 | 62 | /// @} 63 | }// namespace glm 64 | 65 | #include "ulp.inl" 66 | -------------------------------------------------------------------------------- /deps/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/vec1.hpp" 17 | 18 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 19 | # pragma message("GLM: GLM_GTC_vec1 extension included") 20 | #endif 21 | 22 | namespace glm 23 | { 24 | ////////////////////////// 25 | // vec1 definition 26 | 27 | #if(defined(GLM_PRECISION_HIGHP_BOOL)) 28 | typedef highp_bvec1 bvec1; 29 | #elif(defined(GLM_PRECISION_MEDIUMP_BOOL)) 30 | typedef mediump_bvec1 bvec1; 31 | #elif(defined(GLM_PRECISION_LOWP_BOOL)) 32 | typedef lowp_bvec1 bvec1; 33 | #else 34 | /// 1 component vector of boolean. 35 | /// @see gtc_vec1 extension. 36 | typedef highp_bvec1 bvec1; 37 | #endif//GLM_PRECISION 38 | 39 | #if(defined(GLM_PRECISION_HIGHP_FLOAT)) 40 | typedef highp_vec1 vec1; 41 | #elif(defined(GLM_PRECISION_MEDIUMP_FLOAT)) 42 | typedef mediump_vec1 vec1; 43 | #elif(defined(GLM_PRECISION_LOWP_FLOAT)) 44 | typedef lowp_vec1 vec1; 45 | #else 46 | /// 1 component vector of floating-point numbers. 47 | /// @see gtc_vec1 extension. 48 | typedef highp_vec1 vec1; 49 | #endif//GLM_PRECISION 50 | 51 | #if(defined(GLM_PRECISION_HIGHP_DOUBLE)) 52 | typedef highp_dvec1 dvec1; 53 | #elif(defined(GLM_PRECISION_MEDIUMP_DOUBLE)) 54 | typedef mediump_dvec1 dvec1; 55 | #elif(defined(GLM_PRECISION_LOWP_DOUBLE)) 56 | typedef lowp_dvec1 dvec1; 57 | #else 58 | /// 1 component vector of floating-point numbers. 59 | /// @see gtc_vec1 extension. 60 | typedef highp_dvec1 dvec1; 61 | #endif//GLM_PRECISION 62 | 63 | #if(defined(GLM_PRECISION_HIGHP_INT)) 64 | typedef highp_ivec1 ivec1; 65 | #elif(defined(GLM_PRECISION_MEDIUMP_INT)) 66 | typedef mediump_ivec1 ivec1; 67 | #elif(defined(GLM_PRECISION_LOWP_INT)) 68 | typedef lowp_ivec1 ivec1; 69 | #else 70 | /// 1 component vector of signed integer numbers. 71 | /// @see gtc_vec1 extension. 72 | typedef highp_ivec1 ivec1; 73 | #endif//GLM_PRECISION 74 | 75 | #if(defined(GLM_PRECISION_HIGHP_UINT)) 76 | typedef highp_uvec1 uvec1; 77 | #elif(defined(GLM_PRECISION_MEDIUMP_UINT)) 78 | typedef mediump_uvec1 uvec1; 79 | #elif(defined(GLM_PRECISION_LOWP_UINT)) 80 | typedef lowp_uvec1 uvec1; 81 | #else 82 | /// 1 component vector of unsigned integer numbers. 83 | /// @see gtc_vec1 extension. 84 | typedef highp_uvec1 uvec1; 85 | #endif//GLM_PRECISION 86 | 87 | }// namespace glm 88 | 89 | #include "vec1.inl" 90 | -------------------------------------------------------------------------------- /deps/glm/gtc/vec1.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_vec1 2 | /// @file glm/gtc/vec1.inl 3 | -------------------------------------------------------------------------------- /deps/glm/gtx/bit.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_bit 2 | /// @file glm/gtx/bit.inl 3 | 4 | namespace glm 5 | { 6 | /////////////////// 7 | // highestBitValue 8 | 9 | template 10 | GLM_FUNC_QUALIFIER genIUType highestBitValue(genIUType Value) 11 | { 12 | genIUType tmp = Value; 13 | genIUType result = genIUType(0); 14 | while(tmp) 15 | { 16 | result = (tmp & (~tmp + 1)); // grab lowest bit 17 | tmp &= ~result; // clear lowest bit 18 | } 19 | return result; 20 | } 21 | 22 | template 23 | GLM_FUNC_QUALIFIER vec highestBitValue(vec const& v) 24 | { 25 | return detail::functor1::call(highestBitValue, v); 26 | } 27 | 28 | /////////////////// 29 | // lowestBitValue 30 | 31 | template 32 | GLM_FUNC_QUALIFIER genIUType lowestBitValue(genIUType Value) 33 | { 34 | return (Value & (~Value + 1)); 35 | } 36 | 37 | template 38 | GLM_FUNC_QUALIFIER vec lowestBitValue(vec const& v) 39 | { 40 | return detail::functor1::call(lowestBitValue, v); 41 | } 42 | 43 | /////////////////// 44 | // powerOfTwoAbove 45 | 46 | template 47 | GLM_FUNC_QUALIFIER genType powerOfTwoAbove(genType value) 48 | { 49 | return isPowerOfTwo(value) ? value : highestBitValue(value) << 1; 50 | } 51 | 52 | template 53 | GLM_FUNC_QUALIFIER vec powerOfTwoAbove(vec const& v) 54 | { 55 | return detail::functor1::call(powerOfTwoAbove, v); 56 | } 57 | 58 | /////////////////// 59 | // powerOfTwoBelow 60 | 61 | template 62 | GLM_FUNC_QUALIFIER genType powerOfTwoBelow(genType value) 63 | { 64 | return isPowerOfTwo(value) ? value : highestBitValue(value); 65 | } 66 | 67 | template 68 | GLM_FUNC_QUALIFIER vec powerOfTwoBelow(vec const& v) 69 | { 70 | return detail::functor1::call(powerOfTwoBelow, v); 71 | } 72 | 73 | ///////////////////// 74 | // powerOfTwoNearest 75 | 76 | template 77 | GLM_FUNC_QUALIFIER genType powerOfTwoNearest(genType value) 78 | { 79 | if(isPowerOfTwo(value)) 80 | return value; 81 | 82 | genType const prev = highestBitValue(value); 83 | genType const next = prev << 1; 84 | return (next - value) < (value - prev) ? next : prev; 85 | } 86 | 87 | template 88 | GLM_FUNC_QUALIFIER vec powerOfTwoNearest(vec const& v) 89 | { 90 | return detail::functor1::call(powerOfTwoNearest, v); 91 | } 92 | 93 | }//namespace glm 94 | -------------------------------------------------------------------------------- /deps/glm/gtx/closest_point.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_closest_point 2 | /// @file glm/gtx/closest_point.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_closest_point GLM_GTX_closest_point 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Find the point on a straight line which is the closet of a point. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_closest_point 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 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_closest_point extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_closest_point 29 | /// @{ 30 | 31 | /// Find the point on a straight line which is the closet of a point. 32 | /// @see gtx_closest_point 33 | template 34 | GLM_FUNC_DECL vec<3, T, Q> closestPointOnLine( 35 | vec<3, T, Q> const& point, 36 | vec<3, T, Q> const& a, 37 | vec<3, T, Q> const& b); 38 | 39 | /// 2d lines work as well 40 | template 41 | GLM_FUNC_DECL vec<2, T, Q> closestPointOnLine( 42 | vec<2, T, Q> const& point, 43 | vec<2, T, Q> const& a, 44 | vec<2, T, Q> const& b); 45 | 46 | /// @} 47 | }// namespace glm 48 | 49 | #include "closest_point.inl" 50 | -------------------------------------------------------------------------------- /deps/glm/gtx/closest_point.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_closest_point 2 | /// @file glm/gtx/closest_point.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER vec<3, T, Q> closestPointOnLine 8 | ( 9 | vec<3, T, Q> const& point, 10 | vec<3, T, Q> const& a, 11 | vec<3, T, Q> const& b 12 | ) 13 | { 14 | T LineLength = distance(a, b); 15 | vec<3, T, Q> Vector = point - a; 16 | vec<3, T, Q> LineDirection = (b - a) / LineLength; 17 | 18 | // Project Vector to LineDirection to get the distance of point from a 19 | T Distance = dot(Vector, LineDirection); 20 | 21 | if(Distance <= T(0)) return a; 22 | if(Distance >= LineLength) return b; 23 | return a + LineDirection * Distance; 24 | } 25 | 26 | template 27 | GLM_FUNC_QUALIFIER vec<2, T, Q> closestPointOnLine 28 | ( 29 | vec<2, T, Q> const& point, 30 | vec<2, T, Q> const& a, 31 | vec<2, T, Q> const& b 32 | ) 33 | { 34 | T LineLength = distance(a, b); 35 | vec<2, T, Q> Vector = point - a; 36 | vec<2, T, Q> LineDirection = (b - a) / LineLength; 37 | 38 | // Project Vector to LineDirection to get the distance of point from a 39 | T Distance = dot(Vector, LineDirection); 40 | 41 | if(Distance <= T(0)) return a; 42 | if(Distance >= LineLength) return b; 43 | return a + LineDirection * Distance; 44 | } 45 | 46 | }//namespace glm 47 | -------------------------------------------------------------------------------- /deps/glm/gtx/color_encoding.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_color_encoding 2 | /// @file glm/gtx/color_encoding.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_color_encoding (dependence) 6 | /// 7 | /// @defgroup gtx_color_encoding GLM_GTX_color_encoding 8 | /// @ingroup gtx 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 "../vec3.hpp" 20 | #include 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTC_color_encoding extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_color_encoding 29 | /// @{ 30 | 31 | /// Convert a linear sRGB color to D65 YUV. 32 | template 33 | GLM_FUNC_DECL vec<3, T, Q> convertLinearSRGBToD65XYZ(vec<3, T, Q> const& ColorLinearSRGB); 34 | 35 | /// Convert a linear sRGB color to D50 YUV. 36 | template 37 | GLM_FUNC_DECL vec<3, T, Q> convertLinearSRGBToD50XYZ(vec<3, T, Q> const& ColorLinearSRGB); 38 | 39 | /// Convert a D65 YUV color to linear sRGB. 40 | template 41 | GLM_FUNC_DECL vec<3, T, Q> convertD65XYZToLinearSRGB(vec<3, T, Q> const& ColorD65XYZ); 42 | 43 | /// Convert a D65 YUV color to D50 YUV. 44 | template 45 | GLM_FUNC_DECL vec<3, T, Q> convertD65XYZToD50XYZ(vec<3, T, Q> const& ColorD65XYZ); 46 | 47 | /// @} 48 | } //namespace glm 49 | 50 | #include "color_encoding.inl" 51 | -------------------------------------------------------------------------------- /deps/glm/gtx/color_encoding.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_color_encoding 2 | /// @file glm/gtx/color_encoding.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER vec<3, T, Q> convertLinearSRGBToD65XYZ(vec<3, T, Q> const& ColorLinearSRGB) 8 | { 9 | vec<3, T, Q> const M(0.490f, 0.17697f, 0.2f); 10 | vec<3, T, Q> const N(0.31f, 0.8124f, 0.01063f); 11 | vec<3, T, Q> const O(0.490f, 0.01f, 0.99f); 12 | 13 | return (M * ColorLinearSRGB + N * ColorLinearSRGB + O * ColorLinearSRGB) * static_cast(5.650675255693055f); 14 | } 15 | 16 | template 17 | GLM_FUNC_QUALIFIER vec<3, T, Q> convertLinearSRGBToD50XYZ(vec<3, T, Q> const& ColorLinearSRGB) 18 | { 19 | vec<3, T, Q> const M(0.436030342570117f, 0.222438466210245f, 0.013897440074263f); 20 | vec<3, T, Q> const N(0.385101860087134f, 0.716942745571917f, 0.097076381494207f); 21 | vec<3, T, Q> const O(0.143067806654203f, 0.060618777416563f, 0.713926257896652f); 22 | 23 | return M * ColorLinearSRGB + N * ColorLinearSRGB + O * ColorLinearSRGB; 24 | } 25 | 26 | template 27 | GLM_FUNC_QUALIFIER vec<3, T, Q> convertD65XYZToLinearSRGB(vec<3, T, Q> const& ColorD65XYZ) 28 | { 29 | vec<3, T, Q> const M(0.41847f, -0.091169f, 0.0009209f); 30 | vec<3, T, Q> const N(-0.15866f, 0.25243f, 0.015708f); 31 | vec<3, T, Q> const O(0.0009209f, -0.0025498f, 0.1786f); 32 | 33 | return M * ColorD65XYZ + N * ColorD65XYZ + O * ColorD65XYZ; 34 | } 35 | 36 | template 37 | GLM_FUNC_QUALIFIER vec<3, T, Q> convertD65XYZToD50XYZ(vec<3, T, Q> const& ColorD65XYZ) 38 | { 39 | vec<3, T, Q> const M(+1.047844353856414f, +0.029549007606644f, -0.009250984365223f); 40 | vec<3, T, Q> const N(+0.022898981050086f, +0.990508028941971f, +0.015072338237051f); 41 | vec<3, T, Q> const O(-0.050206647741605f, -0.017074711360960f, +0.751717835079977f); 42 | 43 | return M * ColorD65XYZ + N * ColorD65XYZ + O * ColorD65XYZ; 44 | } 45 | 46 | }//namespace glm 47 | -------------------------------------------------------------------------------- /deps/glm/gtx/color_space.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_color_space 2 | /// @file glm/gtx/color_space.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_color_space GLM_GTX_color_space 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Related to RGB to HSV conversions and operations. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_color_space 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 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_color_space extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_color_space 29 | /// @{ 30 | 31 | /// Converts a color from HSV color space to its color in RGB color space. 32 | /// @see gtx_color_space 33 | template 34 | GLM_FUNC_DECL vec<3, T, Q> rgbColor( 35 | vec<3, T, Q> const& hsvValue); 36 | 37 | /// Converts a color from RGB color space to its color in HSV color space. 38 | /// @see gtx_color_space 39 | template 40 | GLM_FUNC_DECL vec<3, T, Q> hsvColor( 41 | vec<3, T, Q> const& rgbValue); 42 | 43 | /// Build a saturation matrix. 44 | /// @see gtx_color_space 45 | template 46 | GLM_FUNC_DECL mat<4, 4, T, defaultp> saturation( 47 | T const s); 48 | 49 | /// Modify the saturation of a color. 50 | /// @see gtx_color_space 51 | template 52 | GLM_FUNC_DECL vec<3, T, Q> saturation( 53 | T const s, 54 | vec<3, T, Q> const& color); 55 | 56 | /// Modify the saturation of a color. 57 | /// @see gtx_color_space 58 | template 59 | GLM_FUNC_DECL vec<4, T, Q> saturation( 60 | T const s, 61 | vec<4, T, Q> const& color); 62 | 63 | /// Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals. 64 | /// @see gtx_color_space 65 | template 66 | GLM_FUNC_DECL T luminosity( 67 | vec<3, T, Q> const& color); 68 | 69 | /// @} 70 | }//namespace glm 71 | 72 | #include "color_space.inl" 73 | -------------------------------------------------------------------------------- /deps/glm/gtx/color_space_YCoCg.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_color_space_YCoCg 2 | /// @file glm/gtx/color_space_YCoCg.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_color_space_YCoCg GLM_GTX_color_space_YCoCg 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// RGB to YCoCg conversions and operations 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_color_space_YCoCg 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 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_color_space_YCoCg extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_color_space_YCoCg 29 | /// @{ 30 | 31 | /// Convert a color from RGB color space to YCoCg color space. 32 | /// @see gtx_color_space_YCoCg 33 | template 34 | GLM_FUNC_DECL vec<3, T, Q> rgb2YCoCg( 35 | vec<3, T, Q> const& rgbColor); 36 | 37 | /// Convert a color from YCoCg color space to RGB color space. 38 | /// @see gtx_color_space_YCoCg 39 | template 40 | GLM_FUNC_DECL vec<3, T, Q> YCoCg2rgb( 41 | vec<3, T, Q> const& YCoCgColor); 42 | 43 | /// Convert a color from RGB color space to YCoCgR color space. 44 | /// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range" 45 | /// @see gtx_color_space_YCoCg 46 | template 47 | GLM_FUNC_DECL vec<3, T, Q> rgb2YCoCgR( 48 | vec<3, T, Q> const& rgbColor); 49 | 50 | /// Convert a color from YCoCgR color space to RGB color space. 51 | /// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range" 52 | /// @see gtx_color_space_YCoCg 53 | template 54 | GLM_FUNC_DECL vec<3, T, Q> YCoCgR2rgb( 55 | vec<3, T, Q> const& YCoCgColor); 56 | 57 | /// @} 58 | }//namespace glm 59 | 60 | #include "color_space_YCoCg.inl" 61 | -------------------------------------------------------------------------------- /deps/glm/gtx/common.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_common 2 | /// @file glm/gtx/common.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_common GLM_GTX_common 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// @brief Provide functions to increase the compatibility with Cg and HLSL languages 12 | 13 | #pragma once 14 | 15 | // Dependencies: 16 | #include "../vec2.hpp" 17 | #include "../vec3.hpp" 18 | #include "../vec4.hpp" 19 | #include "../gtc/vec1.hpp" 20 | 21 | #ifndef GLM_ENABLE_EXPERIMENTAL 22 | # error "GLM: GLM_GTX_common 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 | #endif 24 | 25 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 26 | # pragma message("GLM: GLM_GTX_common extension included") 27 | #endif 28 | 29 | namespace glm 30 | { 31 | /// @addtogroup gtx_common 32 | /// @{ 33 | 34 | /// Returns true if x is a denormalized number 35 | /// Numbers whose absolute value is too small to be represented in the normal format are represented in an alternate, denormalized format. 36 | /// This format is less precise but can represent values closer to zero. 37 | /// 38 | /// @tparam genType Floating-point scalar or vector types. 39 | /// 40 | /// @see GLSL isnan man page 41 | /// @see GLSL 4.20.8 specification, section 8.3 Common Functions 42 | template 43 | GLM_FUNC_DECL typename genType::bool_type isdenormal(genType const& x); 44 | 45 | /// Similar to 'mod' but with a different rounding and integer support. 46 | /// Returns 'x - y * trunc(x/y)' instead of 'x - y * floor(x/y)' 47 | /// 48 | /// @see GLSL mod vs HLSL fmod 49 | /// @see GLSL mod man page 50 | template 51 | GLM_FUNC_DECL vec fmod(vec const& v); 52 | 53 | /// @} 54 | }//namespace glm 55 | 56 | #include "common.inl" 57 | -------------------------------------------------------------------------------- /deps/glm/gtx/compatibility.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_compatibility 2 | /// @file glm/gtx/compatibility.inl 3 | 4 | #include 5 | 6 | namespace glm 7 | { 8 | // isfinite 9 | template 10 | GLM_FUNC_QUALIFIER bool isfinite( 11 | genType const& x) 12 | { 13 | # if GLM_HAS_CXX11_STL 14 | return std::isfinite(x) != 0; 15 | # elif GLM_COMPILER & GLM_COMPILER_VC 16 | return _finite(x); 17 | # elif GLM_COMPILER & GLM_COMPILER_GCC && GLM_PLATFORM & GLM_PLATFORM_ANDROID 18 | return _isfinite(x) != 0; 19 | # else 20 | if (std::numeric_limits::is_integer || std::denorm_absent == std::numeric_limits::has_denorm) 21 | return std::numeric_limits::min() <= x && std::numeric_limits::max() >= x; 22 | else 23 | return -std::numeric_limits::max() <= x && std::numeric_limits::max() >= x; 24 | # endif 25 | } 26 | 27 | template 28 | GLM_FUNC_QUALIFIER vec<1, bool, Q> isfinite( 29 | vec<1, T, Q> const& x) 30 | { 31 | return vec<1, bool, Q>( 32 | isfinite(x.x)); 33 | } 34 | 35 | template 36 | GLM_FUNC_QUALIFIER vec<2, bool, Q> isfinite( 37 | vec<2, T, Q> const& x) 38 | { 39 | return vec<2, bool, Q>( 40 | isfinite(x.x), 41 | isfinite(x.y)); 42 | } 43 | 44 | template 45 | GLM_FUNC_QUALIFIER vec<3, bool, Q> isfinite( 46 | vec<3, T, Q> const& x) 47 | { 48 | return vec<3, bool, Q>( 49 | isfinite(x.x), 50 | isfinite(x.y), 51 | isfinite(x.z)); 52 | } 53 | 54 | template 55 | GLM_FUNC_QUALIFIER vec<4, bool, Q> isfinite( 56 | vec<4, T, Q> const& x) 57 | { 58 | return vec<4, bool, Q>( 59 | isfinite(x.x), 60 | isfinite(x.y), 61 | isfinite(x.z), 62 | isfinite(x.w)); 63 | } 64 | 65 | }//namespace glm 66 | -------------------------------------------------------------------------------- /deps/glm/gtx/component_wise.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_component_wise 2 | /// @file glm/gtx/component_wise.hpp 3 | /// @date 2007-05-21 / 2011-06-07 4 | /// @author Christophe Riccio 5 | /// 6 | /// @see core (dependence) 7 | /// 8 | /// @defgroup gtx_component_wise GLM_GTX_component_wise 9 | /// @ingroup gtx 10 | /// 11 | /// Include to use the features of this extension. 12 | /// 13 | /// Operations between components of a type 14 | 15 | #pragma once 16 | 17 | // Dependencies 18 | #include "../detail/setup.hpp" 19 | #include "../detail/qualifier.hpp" 20 | 21 | #ifndef GLM_ENABLE_EXPERIMENTAL 22 | # error "GLM: GLM_GTX_component_wise 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 | #endif 24 | 25 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 26 | # pragma message("GLM: GLM_GTX_component_wise extension included") 27 | #endif 28 | 29 | namespace glm 30 | { 31 | /// @addtogroup gtx_component_wise 32 | /// @{ 33 | 34 | /// Convert an integer vector to a normalized float vector. 35 | /// If the parameter value type is already a floating qualifier type, the value is passed through. 36 | /// @see gtx_component_wise 37 | template 38 | GLM_FUNC_DECL vec compNormalize(vec const& v); 39 | 40 | /// Convert a normalized float vector to an integer vector. 41 | /// If the parameter value type is already a floating qualifier type, the value is passed through. 42 | /// @see gtx_component_wise 43 | template 44 | GLM_FUNC_DECL vec compScale(vec const& v); 45 | 46 | /// Add all vector components together. 47 | /// @see gtx_component_wise 48 | template 49 | GLM_FUNC_DECL typename genType::value_type compAdd(genType const& v); 50 | 51 | /// Multiply all vector components together. 52 | /// @see gtx_component_wise 53 | template 54 | GLM_FUNC_DECL typename genType::value_type compMul(genType const& v); 55 | 56 | /// Find the minimum value between single vector components. 57 | /// @see gtx_component_wise 58 | template 59 | GLM_FUNC_DECL typename genType::value_type compMin(genType const& v); 60 | 61 | /// Find the maximum value between single vector components. 62 | /// @see gtx_component_wise 63 | template 64 | GLM_FUNC_DECL typename genType::value_type compMax(genType const& v); 65 | 66 | /// @} 67 | }//namespace glm 68 | 69 | #include "component_wise.inl" 70 | -------------------------------------------------------------------------------- /deps/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 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_extend extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_extend 29 | /// @{ 30 | 31 | /// Extends of Length the Origin position using the (Source - Origin) direction. 32 | /// @see gtx_extend 33 | template 34 | GLM_FUNC_DECL genType extend( 35 | genType const& Origin, 36 | genType const& Source, 37 | typename genType::value_type const Length); 38 | 39 | /// @} 40 | }//namespace glm 41 | 42 | #include "extend.inl" 43 | -------------------------------------------------------------------------------- /deps/glm/gtx/extend.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_extend 2 | /// @file glm/gtx/extend.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER genType extend 8 | ( 9 | genType const& Origin, 10 | genType const& Source, 11 | genType const& Distance 12 | ) 13 | { 14 | return Origin + (Source - Origin) * Distance; 15 | } 16 | 17 | template 18 | GLM_FUNC_QUALIFIER vec<2, T, Q> extend 19 | ( 20 | vec<2, T, Q> const& Origin, 21 | vec<2, T, Q> const& Source, 22 | T const& Distance 23 | ) 24 | { 25 | return Origin + (Source - Origin) * Distance; 26 | } 27 | 28 | template 29 | GLM_FUNC_QUALIFIER vec<3, T, Q> extend 30 | ( 31 | vec<3, T, Q> const& Origin, 32 | vec<3, T, Q> const& Source, 33 | T const& Distance 34 | ) 35 | { 36 | return Origin + (Source - Origin) * Distance; 37 | } 38 | 39 | template 40 | GLM_FUNC_QUALIFIER vec<4, T, Q> extend 41 | ( 42 | vec<4, T, Q> const& Origin, 43 | vec<4, T, Q> const& Source, 44 | T const& Distance 45 | ) 46 | { 47 | return Origin + (Source - Origin) * Distance; 48 | } 49 | }//namespace glm 50 | -------------------------------------------------------------------------------- /deps/glm/gtx/exterior_product.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_exterior_product 2 | /// @file glm/gtx/exterior_product.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_exterior_product (dependence) 6 | /// 7 | /// @defgroup gtx_exterior_product GLM_GTX_exterior_product 8 | /// @ingroup gtx 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 | 20 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 21 | # pragma message("GLM: GLM_GTX_exterior_product extension included") 22 | #endif 23 | 24 | namespace glm 25 | { 26 | /// @addtogroup gtx_exterior_product 27 | /// @{ 28 | 29 | /// Returns the cross product of x and y. 30 | /// 31 | /// @tparam T Floating-point scalar types 32 | /// @tparam Q Value from qualifier enum 33 | /// 34 | /// @see Exterior product 35 | template 36 | GLM_FUNC_DECL T cross(vec<2, T, Q> const& v, vec<2, T, Q> const& u); 37 | 38 | /// @} 39 | } //namespace glm 40 | 41 | #include "exterior_product.inl" 42 | -------------------------------------------------------------------------------- /deps/glm/gtx/exterior_product.inl: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/detail/func_geometric.inl 3 | 4 | #include 5 | 6 | namespace glm { 7 | namespace detail 8 | { 9 | template 10 | struct compute_cross_vec2 11 | { 12 | GLM_FUNC_QUALIFIER static T call(vec<2, T, Q> const& v, vec<2, T, Q> const& u) 13 | { 14 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'cross' accepts only floating-point inputs"); 15 | 16 | return v.x * u.y - u.x * v.y; 17 | } 18 | }; 19 | }//namespace detail 20 | 21 | template 22 | GLM_FUNC_QUALIFIER T cross(vec<2, T, Q> const& x, vec<2, T, Q> const& y) 23 | { 24 | return detail::compute_cross_vec2::value>::call(x, y); 25 | } 26 | }//namespace glm 27 | 28 | -------------------------------------------------------------------------------- /deps/glm/gtx/fast_square_root.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_fast_square_root 2 | /// @file glm/gtx/fast_square_root.inl 3 | 4 | namespace glm 5 | { 6 | // fastSqrt 7 | template 8 | GLM_FUNC_QUALIFIER genType fastSqrt(genType x) 9 | { 10 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fastSqrt' only accept floating-point input"); 11 | 12 | return genType(1) / fastInverseSqrt(x); 13 | } 14 | 15 | template 16 | GLM_FUNC_QUALIFIER vec fastSqrt(vec const& x) 17 | { 18 | return detail::functor1::call(fastSqrt, x); 19 | } 20 | 21 | // fastInversesqrt 22 | template 23 | GLM_FUNC_QUALIFIER genType fastInverseSqrt(genType x) 24 | { 25 | # ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6 26 | vec<1, T, Q> tmp(detail::compute_inversesqrt::value>::call(vec<1, genType, lowp>(x))); 27 | return tmp.x; 28 | # else 29 | return detail::compute_inversesqrt<1, genType, lowp, detail::is_aligned::value>::call(vec<1, genType, lowp>(x)).x; 30 | # endif 31 | } 32 | 33 | template 34 | GLM_FUNC_QUALIFIER vec fastInverseSqrt(vec const& x) 35 | { 36 | return detail::compute_inversesqrt::value>::call(x); 37 | } 38 | 39 | // fastLength 40 | template 41 | GLM_FUNC_QUALIFIER genType fastLength(genType x) 42 | { 43 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fastLength' only accept floating-point inputs"); 44 | 45 | return abs(x); 46 | } 47 | 48 | template 49 | GLM_FUNC_QUALIFIER T fastLength(vec const& x) 50 | { 51 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fastLength' only accept floating-point inputs"); 52 | 53 | return fastSqrt(dot(x, x)); 54 | } 55 | 56 | // fastDistance 57 | template 58 | GLM_FUNC_QUALIFIER genType fastDistance(genType x, genType y) 59 | { 60 | return fastLength(y - x); 61 | } 62 | 63 | template 64 | GLM_FUNC_QUALIFIER T fastDistance(vec const& x, vec const& y) 65 | { 66 | return fastLength(y - x); 67 | } 68 | 69 | // fastNormalize 70 | template 71 | GLM_FUNC_QUALIFIER genType fastNormalize(genType x) 72 | { 73 | return x > genType(0) ? genType(1) : -genType(1); 74 | } 75 | 76 | template 77 | GLM_FUNC_QUALIFIER vec fastNormalize(vec const& x) 78 | { 79 | return x * fastInverseSqrt(dot(x, x)); 80 | } 81 | }//namespace glm 82 | -------------------------------------------------------------------------------- /deps/glm/gtx/fast_trigonometry.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_fast_trigonometry 2 | /// @file glm/gtx/fast_trigonometry.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_fast_trigonometry GLM_GTX_fast_trigonometry 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Fast but less accurate implementations of trigonometric functions. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../gtc/constants.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_fast_trigonometry 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 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_fast_trigonometry extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_fast_trigonometry 29 | /// @{ 30 | 31 | /// Wrap an angle to [0 2pi[ 32 | /// From GLM_GTX_fast_trigonometry extension. 33 | template 34 | GLM_FUNC_DECL T wrapAngle(T angle); 35 | 36 | /// Faster than the common sin function but less accurate. 37 | /// From GLM_GTX_fast_trigonometry extension. 38 | template 39 | GLM_FUNC_DECL T fastSin(T angle); 40 | 41 | /// Faster than the common cos function but less accurate. 42 | /// From GLM_GTX_fast_trigonometry extension. 43 | template 44 | GLM_FUNC_DECL T fastCos(T angle); 45 | 46 | /// Faster than the common tan function but less accurate. 47 | /// Defined between -2pi and 2pi. 48 | /// From GLM_GTX_fast_trigonometry extension. 49 | template 50 | GLM_FUNC_DECL T fastTan(T angle); 51 | 52 | /// Faster than the common asin function but less accurate. 53 | /// Defined between -2pi and 2pi. 54 | /// From GLM_GTX_fast_trigonometry extension. 55 | template 56 | GLM_FUNC_DECL T fastAsin(T angle); 57 | 58 | /// Faster than the common acos function but less accurate. 59 | /// Defined between -2pi and 2pi. 60 | /// From GLM_GTX_fast_trigonometry extension. 61 | template 62 | GLM_FUNC_DECL T fastAcos(T angle); 63 | 64 | /// Faster than the common atan function but less accurate. 65 | /// Defined between -2pi and 2pi. 66 | /// From GLM_GTX_fast_trigonometry extension. 67 | template 68 | GLM_FUNC_DECL T fastAtan(T y, T x); 69 | 70 | /// Faster than the common atan function but less accurate. 71 | /// Defined between -2pi and 2pi. 72 | /// From GLM_GTX_fast_trigonometry extension. 73 | template 74 | GLM_FUNC_DECL T fastAtan(T angle); 75 | 76 | /// @} 77 | }//namespace glm 78 | 79 | #include "fast_trigonometry.inl" 80 | -------------------------------------------------------------------------------- /deps/glm/gtx/float_notmalize.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_float_normalize 2 | /// @file glm/gtx/float_normalize.inl 3 | 4 | #include 5 | 6 | namespace glm 7 | { 8 | template 9 | GLM_FUNC_QUALIFIER vec floatNormalize(vec const& v) 10 | { 11 | return vec(v) / static_cast(std::numeric_limits::max()); 12 | } 13 | 14 | }//namespace glm 15 | -------------------------------------------------------------------------------- /deps/glm/gtx/functions.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_functions 2 | /// @file glm/gtx/functions.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_quaternion (dependence) 6 | /// 7 | /// @defgroup gtx_functions GLM_GTX_functions 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// List of useful common functions. 13 | 14 | #pragma once 15 | 16 | // Dependencies 17 | #include "../detail/setup.hpp" 18 | #include "../detail/qualifier.hpp" 19 | #include "../detail/type_vec2.hpp" 20 | 21 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 22 | # pragma message("GLM: GLM_GTX_functions extension included") 23 | #endif 24 | 25 | namespace glm 26 | { 27 | /// @addtogroup gtx_functions 28 | /// @{ 29 | 30 | /// 1D gauss function 31 | /// 32 | /// @see gtc_epsilon 33 | template 34 | GLM_FUNC_DECL T gauss( 35 | T x, 36 | T ExpectedValue, 37 | T StandardDeviation); 38 | 39 | /// 2D gauss function 40 | /// 41 | /// @see gtc_epsilon 42 | template 43 | GLM_FUNC_DECL T gauss( 44 | vec<2, T, Q> const& Coord, 45 | vec<2, T, Q> const& ExpectedValue, 46 | vec<2, T, Q> const& StandardDeviation); 47 | 48 | /// @} 49 | }//namespace glm 50 | 51 | #include "functions.inl" 52 | 53 | -------------------------------------------------------------------------------- /deps/glm/gtx/functions.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_functions 2 | /// @file glm/gtx/functions.inl 3 | 4 | #include "../exponential.hpp" 5 | 6 | namespace glm 7 | { 8 | template 9 | GLM_FUNC_QUALIFIER T gauss 10 | ( 11 | T x, 12 | T ExpectedValue, 13 | T StandardDeviation 14 | ) 15 | { 16 | return exp(-((x - ExpectedValue) * (x - ExpectedValue)) / (static_cast(2) * StandardDeviation * StandardDeviation)) / (StandardDeviation * sqrt(static_cast(6.28318530717958647692528676655900576))); 17 | } 18 | 19 | template 20 | GLM_FUNC_QUALIFIER T gauss 21 | ( 22 | vec<2, T, Q> const& Coord, 23 | vec<2, T, Q> const& ExpectedValue, 24 | vec<2, T, Q> const& StandardDeviation 25 | ) 26 | { 27 | vec<2, T, Q> const Squared = ((Coord - ExpectedValue) * (Coord - ExpectedValue)) / (static_cast(2) * StandardDeviation * StandardDeviation); 28 | return exp(-(Squared.x + Squared.y)); 29 | } 30 | }//namespace glm 31 | 32 | -------------------------------------------------------------------------------- /deps/glm/gtx/gradient_paint.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_gradient_paint 2 | /// @file glm/gtx/gradient_paint.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_optimum_pow (dependence) 6 | /// 7 | /// @defgroup gtx_gradient_paint GLM_GTX_gradient_paint 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Functions that return the color of procedural gradient for specific coordinates. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | #include "../gtx/optimum_pow.hpp" 19 | 20 | #ifndef GLM_ENABLE_EXPERIMENTAL 21 | # error "GLM: GLM_GTX_gradient_paint 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 | #endif 23 | 24 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 25 | # pragma message("GLM: GLM_GTX_gradient_paint extension included") 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtx_gradient_paint 31 | /// @{ 32 | 33 | /// Return a color from a radial gradient. 34 | /// @see - gtx_gradient_paint 35 | template 36 | GLM_FUNC_DECL T radialGradient( 37 | vec<2, T, Q> const& Center, 38 | T const& Radius, 39 | vec<2, T, Q> const& Focal, 40 | vec<2, T, Q> const& Position); 41 | 42 | /// Return a color from a linear gradient. 43 | /// @see - gtx_gradient_paint 44 | template 45 | GLM_FUNC_DECL T linearGradient( 46 | vec<2, T, Q> const& Point0, 47 | vec<2, T, Q> const& Point1, 48 | vec<2, T, Q> const& Position); 49 | 50 | /// @} 51 | }// namespace glm 52 | 53 | #include "gradient_paint.inl" 54 | -------------------------------------------------------------------------------- /deps/glm/gtx/gradient_paint.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_gradient_paint 2 | /// @file glm/gtx/gradient_paint.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER T radialGradient 8 | ( 9 | vec<2, T, Q> const& Center, 10 | T const& Radius, 11 | vec<2, T, Q> const& Focal, 12 | vec<2, T, Q> const& Position 13 | ) 14 | { 15 | vec<2, T, Q> F = Focal - Center; 16 | vec<2, T, Q> D = Position - Focal; 17 | T Radius2 = pow2(Radius); 18 | T Fx2 = pow2(F.x); 19 | T Fy2 = pow2(F.y); 20 | 21 | 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)); 22 | T Denominator = Radius2 - (Fx2 + Fy2); 23 | return Numerator / Denominator; 24 | } 25 | 26 | template 27 | GLM_FUNC_QUALIFIER T linearGradient 28 | ( 29 | vec<2, T, Q> const& Point0, 30 | vec<2, T, Q> const& Point1, 31 | vec<2, T, Q> const& Position 32 | ) 33 | { 34 | vec<2, T, Q> Dist = Point1 - Point0; 35 | return (Dist.x * (Position.x - Point0.x) + Dist.y * (Position.y - Point0.y)) / glm::dot(Dist, Dist); 36 | } 37 | }//namespace glm 38 | -------------------------------------------------------------------------------- /deps/glm/gtx/handed_coordinate_space.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_handed_coordinate_space 2 | /// @file glm/gtx/handed_coordinate_space.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_handed_coordinate_space GLM_GTX_handed_coordinate_space 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// To know if a set of three basis vectors defines a right or left-handed coordinate system. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_handed_coordinate_space 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 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_handed_coordinate_space extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_handed_coordinate_space 29 | /// @{ 30 | 31 | //! Return if a trihedron right handed or not. 32 | //! From GLM_GTX_handed_coordinate_space extension. 33 | template 34 | GLM_FUNC_DECL bool rightHanded( 35 | vec<3, T, Q> const& tangent, 36 | vec<3, T, Q> const& binormal, 37 | vec<3, T, Q> const& normal); 38 | 39 | //! Return if a trihedron left handed or not. 40 | //! From GLM_GTX_handed_coordinate_space extension. 41 | template 42 | GLM_FUNC_DECL bool leftHanded( 43 | vec<3, T, Q> const& tangent, 44 | vec<3, T, Q> const& binormal, 45 | vec<3, T, Q> const& normal); 46 | 47 | /// @} 48 | }// namespace glm 49 | 50 | #include "handed_coordinate_space.inl" 51 | -------------------------------------------------------------------------------- /deps/glm/gtx/handed_coordinate_space.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_handed_coordinate_space 2 | /// @file glm/gtx/handed_coordinate_space.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER bool rightHanded 8 | ( 9 | vec<3, T, Q> const& tangent, 10 | vec<3, T, Q> const& binormal, 11 | vec<3, T, Q> const& normal 12 | ) 13 | { 14 | return dot(cross(normal, tangent), binormal) > T(0); 15 | } 16 | 17 | template 18 | GLM_FUNC_QUALIFIER bool leftHanded 19 | ( 20 | vec<3, T, Q> const& tangent, 21 | vec<3, T, Q> const& binormal, 22 | vec<3, T, Q> const& normal 23 | ) 24 | { 25 | return dot(cross(normal, tangent), binormal) < T(0); 26 | } 27 | }//namespace glm 28 | -------------------------------------------------------------------------------- /deps/glm/gtx/integer.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_integer 2 | /// @file glm/gtx/integer.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_integer GLM_GTX_integer 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Add support for integer for core functions 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | #include "../gtc/integer.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_integer 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 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_integer extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_integer 30 | /// @{ 31 | 32 | //! Returns x raised to the y power. 33 | //! From GLM_GTX_integer extension. 34 | GLM_FUNC_DECL int pow(int x, uint y); 35 | 36 | //! Returns the positive square root of x. 37 | //! From GLM_GTX_integer extension. 38 | GLM_FUNC_DECL int sqrt(int x); 39 | 40 | //! Returns the floor log2 of x. 41 | //! From GLM_GTX_integer extension. 42 | GLM_FUNC_DECL unsigned int floor_log2(unsigned int x); 43 | 44 | //! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y. 45 | //! From GLM_GTX_integer extension. 46 | GLM_FUNC_DECL int mod(int x, int y); 47 | 48 | //! Return the factorial value of a number (!12 max, integer only) 49 | //! From GLM_GTX_integer extension. 50 | template 51 | GLM_FUNC_DECL genType factorial(genType const& x); 52 | 53 | //! 32bit signed integer. 54 | //! From GLM_GTX_integer extension. 55 | typedef signed int sint; 56 | 57 | //! Returns x raised to the y power. 58 | //! From GLM_GTX_integer extension. 59 | GLM_FUNC_DECL uint pow(uint x, uint y); 60 | 61 | //! Returns the positive square root of x. 62 | //! From GLM_GTX_integer extension. 63 | GLM_FUNC_DECL uint sqrt(uint x); 64 | 65 | //! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y. 66 | //! From GLM_GTX_integer extension. 67 | GLM_FUNC_DECL uint mod(uint x, uint y); 68 | 69 | //! Returns the number of leading zeros. 70 | //! From GLM_GTX_integer extension. 71 | GLM_FUNC_DECL uint nlz(uint x); 72 | 73 | /// @} 74 | }//namespace glm 75 | 76 | #include "integer.inl" 77 | -------------------------------------------------------------------------------- /deps/glm/gtx/intersect.hpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/deps/glm/gtx/intersect.hpp -------------------------------------------------------------------------------- /deps/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 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_log_base extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_log_base 29 | /// @{ 30 | 31 | /// Logarithm for any base. 32 | /// From GLM_GTX_log_base. 33 | template 34 | GLM_FUNC_DECL genType log( 35 | genType const& x, 36 | genType const& base); 37 | 38 | /// Logarithm for any base. 39 | /// From GLM_GTX_log_base. 40 | template 41 | GLM_FUNC_DECL vec sign( 42 | vec const& x, 43 | vec const& base); 44 | 45 | /// @} 46 | }//namespace glm 47 | 48 | #include "log_base.inl" 49 | -------------------------------------------------------------------------------- /deps/glm/gtx/log_base.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_log_base 2 | /// @file glm/gtx/log_base.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER genType log(genType const& x, genType const& base) 8 | { 9 | assert(!detail::compute_equal::call(x, static_cast(0))); 10 | return glm::log(x) / glm::log(base); 11 | } 12 | 13 | template 14 | GLM_FUNC_QUALIFIER vec log(vec const& x, vec const& base) 15 | { 16 | return glm::log(x) / glm::log(base); 17 | } 18 | }//namespace glm 19 | -------------------------------------------------------------------------------- /deps/glm/gtx/matrix_cross_product.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_cross_product 2 | /// @file glm/gtx/matrix_cross_product.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_extented_min_max (dependence) 6 | /// 7 | /// @defgroup gtx_matrix_cross_product GLM_GTX_matrix_cross_product 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Build cross product matrices 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_matrix_cross_product is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 21 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_matrix_cross_product extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_matrix_cross_product 30 | /// @{ 31 | 32 | //! Build a cross product matrix. 33 | //! From GLM_GTX_matrix_cross_product extension. 34 | template 35 | GLM_FUNC_DECL mat<3, 3, T, Q> matrixCross3( 36 | vec<3, T, Q> const& x); 37 | 38 | //! Build a cross product matrix. 39 | //! From GLM_GTX_matrix_cross_product extension. 40 | template 41 | GLM_FUNC_DECL mat<4, 4, T, Q> matrixCross4( 42 | vec<3, T, Q> const& x); 43 | 44 | /// @} 45 | }//namespace glm 46 | 47 | #include "matrix_cross_product.inl" 48 | -------------------------------------------------------------------------------- /deps/glm/gtx/matrix_cross_product.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_cross_product 2 | /// @file glm/gtx/matrix_cross_product.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> matrixCross3 8 | ( 9 | vec<3, T, Q> const& x 10 | ) 11 | { 12 | mat<3, 3, T, Q> Result(T(0)); 13 | Result[0][1] = x.z; 14 | Result[1][0] = -x.z; 15 | Result[0][2] = -x.y; 16 | Result[2][0] = x.y; 17 | Result[1][2] = x.x; 18 | Result[2][1] = -x.x; 19 | return Result; 20 | } 21 | 22 | template 23 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> matrixCross4 24 | ( 25 | vec<3, T, Q> const& x 26 | ) 27 | { 28 | mat<4, 4, T, Q> Result(T(0)); 29 | Result[0][1] = x.z; 30 | Result[1][0] = -x.z; 31 | Result[0][2] = -x.y; 32 | Result[2][0] = x.y; 33 | Result[1][2] = x.x; 34 | Result[2][1] = -x.x; 35 | return Result; 36 | } 37 | 38 | }//namespace glm 39 | -------------------------------------------------------------------------------- /deps/glm/gtx/matrix_decompose.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_decompose 2 | /// @file glm/gtx/matrix_decompose.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_matrix_decompose GLM_GTX_matrix_decompose 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Decomposes a model matrix to translations, rotation and scale components 12 | 13 | #pragma once 14 | 15 | // Dependencies 16 | #include "../mat4x4.hpp" 17 | #include "../vec3.hpp" 18 | #include "../vec4.hpp" 19 | #include "../geometric.hpp" 20 | #include "../gtc/quaternion.hpp" 21 | #include "../gtc/matrix_transform.hpp" 22 | 23 | #ifndef GLM_ENABLE_EXPERIMENTAL 24 | # error "GLM: GLM_GTX_matrix_decompose 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." 25 | #endif 26 | 27 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 28 | # pragma message("GLM: GLM_GTX_matrix_decompose extension included") 29 | #endif 30 | 31 | namespace glm 32 | { 33 | /// @addtogroup gtx_matrix_decompose 34 | /// @{ 35 | 36 | /// Decomposes a model matrix to translations, rotation and scale components 37 | /// @see gtx_matrix_decompose 38 | template 39 | GLM_FUNC_DECL bool decompose( 40 | mat<4, 4, T, Q> const& modelMatrix, 41 | vec<3, T, Q> & scale, tquat & orientation, vec<3, T, Q> & translation, vec<3, T, Q> & skew, vec<4, T, Q> & perspective); 42 | 43 | /// @} 44 | }//namespace glm 45 | 46 | #include "matrix_decompose.inl" 47 | -------------------------------------------------------------------------------- /deps/glm/gtx/matrix_factorisation.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_factorisation 2 | /// @file glm/gtx/matrix_factorisation.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_matrix_factorisation GLM_GTX_matrix_factorisation 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Functions to factor matrices in various forms 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_matrix_factorisation 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 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_matrix_factorisation extension included") 24 | #endif 25 | 26 | /* 27 | Suggestions: 28 | - Move helper functions flipud and fliplr to another file: They may be helpful in more general circumstances. 29 | - Implement other types of matrix factorisation, such as: QL and LQ, L(D)U, eigendecompositions, etc... 30 | */ 31 | 32 | namespace glm 33 | { 34 | /// @addtogroup gtx_matrix_factorisation 35 | /// @{ 36 | 37 | /// Flips the matrix rows up and down. 38 | /// 39 | /// From GLM_GTX_matrix_factorisation extension. 40 | template 41 | GLM_FUNC_DECL mat flipud(mat const& in); 42 | 43 | /// Flips the matrix columns right and left. 44 | /// 45 | /// From GLM_GTX_matrix_factorisation extension. 46 | template 47 | GLM_FUNC_DECL mat fliplr(mat const& in); 48 | 49 | /// Performs QR factorisation of a matrix. 50 | /// Returns 2 matrices, q and r, such that the columns of q are orthonormal and span the same subspace than those of the input matrix, r is an upper triangular matrix, and q*r=in. 51 | /// Given an n-by-m input matrix, q has dimensions min(n,m)-by-m, and r has dimensions n-by-min(n,m). 52 | /// 53 | /// From GLM_GTX_matrix_factorisation extension. 54 | template 55 | GLM_FUNC_DECL void qr_decompose(mat const& in, mat<(C < R ? C : R), R, T, Q>& q, mat& r); 56 | 57 | /// Performs RQ factorisation of a matrix. 58 | /// Returns 2 matrices, r and q, such that r is an upper triangular matrix, the rows of q are orthonormal and span the same subspace than those of the input matrix, and r*q=in. 59 | /// Note that in the context of RQ factorisation, the diagonal is seen as starting in the lower-right corner of the matrix, instead of the usual upper-left. 60 | /// Given an n-by-m input matrix, r has dimensions min(n,m)-by-m, and q has dimensions n-by-min(n,m). 61 | /// 62 | /// From GLM_GTX_matrix_factorisation extension. 63 | template 64 | GLM_FUNC_DECL void rq_decompose(mat const& in, mat<(C < R ? C : R), R, T, Q>& r, mat& q); 65 | 66 | /// @} 67 | } 68 | 69 | #include "matrix_factorisation.inl" 70 | -------------------------------------------------------------------------------- /deps/glm/gtx/matrix_factorisation.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/deps/glm/gtx/matrix_factorisation.inl -------------------------------------------------------------------------------- /deps/glm/gtx/matrix_interpolation.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_interpolation 2 | /// @file glm/gtx/matrix_interpolation.hpp 3 | /// @author Ghenadii Ursachi (the.asteroth@gmail.com) 4 | /// 5 | /// @see core (dependence) 6 | /// 7 | /// @defgroup gtx_matrix_interpolation GLM_GTX_matrix_interpolation 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Allows to directly interpolate two exiciting matrices. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_matrix_interpolation 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 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_matrix_interpolation extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_matrix_interpolation 30 | /// @{ 31 | 32 | /// Get the axis and angle of the rotation from a matrix. 33 | /// From GLM_GTX_matrix_interpolation extension. 34 | template 35 | GLM_FUNC_DECL void axisAngle( 36 | mat<4, 4, T, Q> const& mat, 37 | vec<3, T, Q> & axis, 38 | T & angle); 39 | 40 | /// Build a matrix from axis and angle. 41 | /// From GLM_GTX_matrix_interpolation extension. 42 | template 43 | GLM_FUNC_DECL mat<4, 4, T, Q> axisAngleMatrix( 44 | vec<3, T, Q> const& axis, 45 | T const angle); 46 | 47 | /// Extracts the rotation part of a matrix. 48 | /// From GLM_GTX_matrix_interpolation extension. 49 | template 50 | GLM_FUNC_DECL mat<4, 4, T, Q> extractMatrixRotation( 51 | mat<4, 4, T, Q> const& mat); 52 | 53 | /// Build a interpolation of 4 * 4 matrixes. 54 | /// From GLM_GTX_matrix_interpolation extension. 55 | /// Warning! works only with rotation and/or translation matrixes, scale will generate unexpected results. 56 | template 57 | GLM_FUNC_DECL mat<4, 4, T, Q> interpolate( 58 | mat<4, 4, T, Q> const& m1, 59 | mat<4, 4, T, Q> const& m2, 60 | T const delta); 61 | 62 | /// @} 63 | }//namespace glm 64 | 65 | #include "matrix_interpolation.inl" 66 | -------------------------------------------------------------------------------- /deps/glm/gtx/matrix_operation.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_operation 2 | /// @file glm/gtx/matrix_operation.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_matrix_operation GLM_GTX_matrix_operation 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Build diagonal matrices from vectors. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_matrix_operation 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 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_matrix_operation extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_matrix_operation 29 | /// @{ 30 | 31 | //! Build a diagonal matrix. 32 | //! From GLM_GTX_matrix_operation extension. 33 | template 34 | GLM_FUNC_DECL mat<2, 2, T, Q> diagonal2x2( 35 | vec<2, T, Q> const& v); 36 | 37 | //! Build a diagonal matrix. 38 | //! From GLM_GTX_matrix_operation extension. 39 | template 40 | GLM_FUNC_DECL mat<2, 3, T, Q> diagonal2x3( 41 | vec<2, T, Q> const& v); 42 | 43 | //! Build a diagonal matrix. 44 | //! From GLM_GTX_matrix_operation extension. 45 | template 46 | GLM_FUNC_DECL mat<2, 4, T, Q> diagonal2x4( 47 | vec<2, T, Q> const& v); 48 | 49 | //! Build a diagonal matrix. 50 | //! From GLM_GTX_matrix_operation extension. 51 | template 52 | GLM_FUNC_DECL mat<3, 2, T, Q> diagonal3x2( 53 | vec<2, T, Q> const& v); 54 | 55 | //! Build a diagonal matrix. 56 | //! From GLM_GTX_matrix_operation extension. 57 | template 58 | GLM_FUNC_DECL mat<3, 3, T, Q> diagonal3x3( 59 | vec<3, T, Q> const& v); 60 | 61 | //! Build a diagonal matrix. 62 | //! From GLM_GTX_matrix_operation extension. 63 | template 64 | GLM_FUNC_DECL mat<3, 4, T, Q> diagonal3x4( 65 | vec<3, T, Q> const& v); 66 | 67 | //! Build a diagonal matrix. 68 | //! From GLM_GTX_matrix_operation extension. 69 | template 70 | GLM_FUNC_DECL mat<4, 2, T, Q> diagonal4x2( 71 | vec<2, T, Q> const& v); 72 | 73 | //! Build a diagonal matrix. 74 | //! From GLM_GTX_matrix_operation extension. 75 | template 76 | GLM_FUNC_DECL mat<4, 3, T, Q> diagonal4x3( 77 | vec<3, T, Q> const& v); 78 | 79 | //! Build a diagonal matrix. 80 | //! From GLM_GTX_matrix_operation extension. 81 | template 82 | GLM_FUNC_DECL mat<4, 4, T, Q> diagonal4x4( 83 | vec<4, T, Q> const& v); 84 | 85 | /// @} 86 | }//namespace glm 87 | 88 | #include "matrix_operation.inl" 89 | -------------------------------------------------------------------------------- /deps/glm/gtx/matrix_operation.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_operation 2 | /// @file glm/gtx/matrix_operation.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER mat<2, 2, T, Q> diagonal2x2 8 | ( 9 | vec<2, T, Q> const& v 10 | ) 11 | { 12 | mat<2, 2, T, Q> Result(static_cast(1)); 13 | Result[0][0] = v[0]; 14 | Result[1][1] = v[1]; 15 | return Result; 16 | } 17 | 18 | template 19 | GLM_FUNC_QUALIFIER mat<2, 3, T, Q> diagonal2x3 20 | ( 21 | vec<2, T, Q> const& v 22 | ) 23 | { 24 | mat<2, 3, T, Q> Result(static_cast(1)); 25 | Result[0][0] = v[0]; 26 | Result[1][1] = v[1]; 27 | return Result; 28 | } 29 | 30 | template 31 | GLM_FUNC_QUALIFIER mat<2, 4, T, Q> diagonal2x4 32 | ( 33 | vec<2, T, Q> const& v 34 | ) 35 | { 36 | mat<2, 4, T, Q> Result(static_cast(1)); 37 | Result[0][0] = v[0]; 38 | Result[1][1] = v[1]; 39 | return Result; 40 | } 41 | 42 | template 43 | GLM_FUNC_QUALIFIER mat<3, 2, T, Q> diagonal3x2 44 | ( 45 | vec<2, T, Q> const& v 46 | ) 47 | { 48 | mat<3, 2, T, Q> Result(static_cast(1)); 49 | Result[0][0] = v[0]; 50 | Result[1][1] = v[1]; 51 | return Result; 52 | } 53 | 54 | template 55 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> diagonal3x3 56 | ( 57 | vec<3, T, Q> const& v 58 | ) 59 | { 60 | mat<3, 3, T, Q> Result(static_cast(1)); 61 | Result[0][0] = v[0]; 62 | Result[1][1] = v[1]; 63 | Result[2][2] = v[2]; 64 | return Result; 65 | } 66 | 67 | template 68 | GLM_FUNC_QUALIFIER mat<3, 4, T, Q> diagonal3x4 69 | ( 70 | vec<3, T, Q> const& v 71 | ) 72 | { 73 | mat<3, 4, T, Q> Result(static_cast(1)); 74 | Result[0][0] = v[0]; 75 | Result[1][1] = v[1]; 76 | Result[2][2] = v[2]; 77 | return Result; 78 | } 79 | 80 | template 81 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> diagonal4x4 82 | ( 83 | vec<4, T, Q> const& v 84 | ) 85 | { 86 | mat<4, 4, T, Q> Result(static_cast(1)); 87 | Result[0][0] = v[0]; 88 | Result[1][1] = v[1]; 89 | Result[2][2] = v[2]; 90 | Result[3][3] = v[3]; 91 | return Result; 92 | } 93 | 94 | template 95 | GLM_FUNC_QUALIFIER mat<4, 3, T, Q> diagonal4x3 96 | ( 97 | vec<3, T, Q> const& v 98 | ) 99 | { 100 | mat<4, 3, T, Q> Result(static_cast(1)); 101 | Result[0][0] = v[0]; 102 | Result[1][1] = v[1]; 103 | Result[2][2] = v[2]; 104 | return Result; 105 | } 106 | 107 | template 108 | GLM_FUNC_QUALIFIER mat<4, 2, T, Q> diagonal4x2 109 | ( 110 | vec<2, T, Q> const& v 111 | ) 112 | { 113 | mat<4, 2, T, Q> Result(static_cast(1)); 114 | Result[0][0] = v[0]; 115 | Result[1][1] = v[1]; 116 | return Result; 117 | } 118 | }//namespace glm 119 | -------------------------------------------------------------------------------- /deps/glm/gtx/matrix_query.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_query 2 | /// @file glm/gtx/matrix_query.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_vector_query (dependence) 6 | /// 7 | /// @defgroup gtx_matrix_query GLM_GTX_matrix_query 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Query to evaluate matrix properties 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | #include "../gtx/vector_query.hpp" 19 | #include 20 | 21 | #ifndef GLM_ENABLE_EXPERIMENTAL 22 | # error "GLM: GLM_GTX_matrix_query 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 | #endif 24 | 25 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 26 | # pragma message("GLM: GLM_GTX_matrix_query extension included") 27 | #endif 28 | 29 | namespace glm 30 | { 31 | /// @addtogroup gtx_matrix_query 32 | /// @{ 33 | 34 | /// Return whether a matrix a null matrix. 35 | /// From GLM_GTX_matrix_query extension. 36 | template 37 | GLM_FUNC_DECL bool isNull(mat<2, 2, T, Q> const& m, T const& epsilon); 38 | 39 | /// Return whether a matrix a null matrix. 40 | /// From GLM_GTX_matrix_query extension. 41 | template 42 | GLM_FUNC_DECL bool isNull(mat<3, 3, T, Q> const& m, T const& epsilon); 43 | 44 | /// Return whether a matrix is a null matrix. 45 | /// From GLM_GTX_matrix_query extension. 46 | template 47 | GLM_FUNC_DECL bool isNull(mat<4, 4, T, Q> const& m, T const& epsilon); 48 | 49 | /// Return whether a matrix is an identity matrix. 50 | /// From GLM_GTX_matrix_query extension. 51 | template class matType> 52 | GLM_FUNC_DECL bool isIdentity(matType const& m, T const& epsilon); 53 | 54 | /// Return whether a matrix is a normalized matrix. 55 | /// From GLM_GTX_matrix_query extension. 56 | template 57 | GLM_FUNC_DECL bool isNormalized(mat<2, 2, T, Q> const& m, T const& epsilon); 58 | 59 | /// Return whether a matrix is a normalized matrix. 60 | /// From GLM_GTX_matrix_query extension. 61 | template 62 | GLM_FUNC_DECL bool isNormalized(mat<3, 3, T, Q> const& m, T const& epsilon); 63 | 64 | /// Return whether a matrix is a normalized matrix. 65 | /// From GLM_GTX_matrix_query extension. 66 | template 67 | GLM_FUNC_DECL bool isNormalized(mat<4, 4, T, Q> const& m, T const& epsilon); 68 | 69 | /// Return whether a matrix is an orthonormalized matrix. 70 | /// From GLM_GTX_matrix_query extension. 71 | template class matType> 72 | GLM_FUNC_DECL bool isOrthogonal(matType const& m, T const& epsilon); 73 | 74 | /// @} 75 | }//namespace glm 76 | 77 | #include "matrix_query.inl" 78 | -------------------------------------------------------------------------------- /deps/glm/gtx/matrix_transform_2d.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_transform_2d 2 | /// @file glm/gtx/matrix_transform_2d.hpp 3 | /// @author Miguel Ángel Pérez Martínez 4 | /// 5 | /// @see core (dependence) 6 | /// 7 | /// @defgroup gtx_matrix_transform_2d GLM_GTX_matrix_transform_2d 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Defines functions that generate common 2d transformation matrices. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../mat3x3.hpp" 18 | #include "../vec2.hpp" 19 | 20 | #ifndef GLM_ENABLE_EXPERIMENTAL 21 | # error "GLM: GLM_GTX_matrix_transform_2d 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 | #endif 23 | 24 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 25 | # pragma message("GLM: GLM_GTX_matrix_transform_2d extension included") 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtx_matrix_transform_2d 31 | /// @{ 32 | 33 | /// Builds a translation 3 * 3 matrix created from a vector of 2 components. 34 | /// 35 | /// @param m Input matrix multiplied by this translation matrix. 36 | /// @param v Coordinates of a translation vector. 37 | template 38 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> translate( 39 | mat<3, 3, T, Q> const& m, 40 | vec<2, T, Q> const& v); 41 | 42 | /// Builds a rotation 3 * 3 matrix created from an angle. 43 | /// 44 | /// @param m Input matrix multiplied by this translation matrix. 45 | /// @param angle Rotation angle expressed in radians. 46 | template 47 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> rotate( 48 | mat<3, 3, T, Q> const& m, 49 | T angle); 50 | 51 | /// Builds a scale 3 * 3 matrix created from a vector of 2 components. 52 | /// 53 | /// @param m Input matrix multiplied by this translation matrix. 54 | /// @param v Coordinates of a scale vector. 55 | template 56 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> scale( 57 | mat<3, 3, T, Q> const& m, 58 | vec<2, T, Q> const& v); 59 | 60 | /// Builds an horizontal (parallel to the x axis) shear 3 * 3 matrix. 61 | /// 62 | /// @param m Input matrix multiplied by this translation matrix. 63 | /// @param y Shear factor. 64 | template 65 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearX( 66 | mat<3, 3, T, Q> const& m, 67 | T y); 68 | 69 | /// Builds a vertical (parallel to the y axis) shear 3 * 3 matrix. 70 | /// 71 | /// @param m Input matrix multiplied by this translation matrix. 72 | /// @param x Shear factor. 73 | template 74 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearY( 75 | mat<3, 3, T, Q> const& m, 76 | T x); 77 | 78 | /// @} 79 | }//namespace glm 80 | 81 | #include "matrix_transform_2d.inl" 82 | -------------------------------------------------------------------------------- /deps/glm/gtx/matrix_transform_2d.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_matrix_transform_2d 2 | /// @file glm/gtc/matrix_transform_2d.inl 3 | /// @author Miguel Ángel Pérez Martínez 4 | 5 | #include "../trigonometric.hpp" 6 | 7 | namespace glm 8 | { 9 | 10 | template 11 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> translate( 12 | mat<3, 3, T, Q> const& m, 13 | vec<2, T, Q> const& v) 14 | { 15 | mat<3, 3, T, Q> Result(m); 16 | Result[2] = m[0] * v[0] + m[1] * v[1] + m[2]; 17 | return Result; 18 | } 19 | 20 | 21 | template 22 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> rotate( 23 | mat<3, 3, T, Q> const& m, 24 | T angle) 25 | { 26 | T const a = angle; 27 | T const c = cos(a); 28 | T const s = sin(a); 29 | 30 | mat<3, 3, T, Q> Result; 31 | Result[0] = m[0] * c + m[1] * s; 32 | Result[1] = m[0] * -s + m[1] * c; 33 | Result[2] = m[2]; 34 | return Result; 35 | } 36 | 37 | template 38 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> scale( 39 | mat<3, 3, T, Q> const& m, 40 | vec<2, T, Q> const& v) 41 | { 42 | mat<3, 3, T, Q> Result; 43 | Result[0] = m[0] * v[0]; 44 | Result[1] = m[1] * v[1]; 45 | Result[2] = m[2]; 46 | return Result; 47 | } 48 | 49 | template 50 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearX( 51 | mat<3, 3, T, Q> const& m, 52 | T y) 53 | { 54 | mat<3, 3, T, Q> Result(1); 55 | Result[0][1] = y; 56 | return m * Result; 57 | } 58 | 59 | template 60 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> shearY( 61 | mat<3, 3, T, Q> const& m, 62 | T x) 63 | { 64 | mat<3, 3, T, Q> Result(1); 65 | Result[1][0] = x; 66 | return m * Result; 67 | } 68 | 69 | }//namespace glm 70 | -------------------------------------------------------------------------------- /deps/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 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_mixed_product extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_mixed_product 29 | /// @{ 30 | 31 | /// @brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension) 32 | template 33 | GLM_FUNC_DECL T mixedProduct( 34 | vec<3, T, Q> const& v1, 35 | vec<3, T, Q> const& v2, 36 | vec<3, T, Q> const& v3); 37 | 38 | /// @} 39 | }// namespace glm 40 | 41 | #include "mixed_product.inl" 42 | -------------------------------------------------------------------------------- /deps/glm/gtx/mixed_product.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_mixed_product 2 | /// @file glm/gtx/mixed_product.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER T mixedProduct 8 | ( 9 | vec<3, T, Q> const& v1, 10 | vec<3, T, Q> const& v2, 11 | vec<3, T, Q> const& v3 12 | ) 13 | { 14 | return dot(cross(v1, v2), v3); 15 | } 16 | }//namespace glm 17 | -------------------------------------------------------------------------------- /deps/glm/gtx/norm.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_norm 2 | /// @file glm/gtx/norm.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_quaternion (dependence) 6 | /// 7 | /// @defgroup gtx_norm GLM_GTX_norm 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Various ways to compute vector norms. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../geometric.hpp" 18 | #include "../gtx/quaternion.hpp" 19 | 20 | #ifndef GLM_ENABLE_EXPERIMENTAL 21 | # error "GLM: GLM_GTX_norm 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 | #endif 23 | 24 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 25 | # pragma message("GLM: GLM_GTX_norm extension included") 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtx_norm 31 | /// @{ 32 | 33 | /// Returns the squared length of x. 34 | /// From GLM_GTX_norm extension. 35 | template 36 | GLM_FUNC_DECL T length2(vec const& x); 37 | 38 | /// Returns the squared distance between p0 and p1, i.e., length2(p0 - p1). 39 | /// From GLM_GTX_norm extension. 40 | template 41 | GLM_FUNC_DECL T distance2(vec const& p0, vec const& p1); 42 | 43 | //! Returns the L1 norm between x and y. 44 | //! From GLM_GTX_norm extension. 45 | template 46 | GLM_FUNC_DECL T l1Norm(vec<3, T, Q> const& x, vec<3, T, Q> const& y); 47 | 48 | //! Returns the L1 norm of v. 49 | //! From GLM_GTX_norm extension. 50 | template 51 | GLM_FUNC_DECL T l1Norm(vec<3, T, Q> const& v); 52 | 53 | //! Returns the L2 norm between x and y. 54 | //! From GLM_GTX_norm extension. 55 | template 56 | GLM_FUNC_DECL T l2Norm(vec<3, T, Q> const& x, vec<3, T, Q> const& y); 57 | 58 | //! Returns the L2 norm of v. 59 | //! From GLM_GTX_norm extension. 60 | template 61 | GLM_FUNC_DECL T l2Norm(vec<3, T, Q> const& x); 62 | 63 | //! Returns the L norm between x and y. 64 | //! From GLM_GTX_norm extension. 65 | template 66 | GLM_FUNC_DECL T lxNorm(vec<3, T, Q> const& x, vec<3, T, Q> const& y, unsigned int Depth); 67 | 68 | //! Returns the L norm of v. 69 | //! From GLM_GTX_norm extension. 70 | template 71 | GLM_FUNC_DECL T lxNorm(vec<3, T, Q> const& x, unsigned int Depth); 72 | 73 | /// @} 74 | }//namespace glm 75 | 76 | #include "norm.inl" 77 | -------------------------------------------------------------------------------- /deps/glm/gtx/norm.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_norm 2 | /// @file glm/gtx/norm.inl 3 | 4 | #include "../detail/qualifier.hpp" 5 | 6 | namespace glm{ 7 | namespace detail 8 | { 9 | template 10 | struct compute_length2 11 | { 12 | GLM_FUNC_QUALIFIER static T call(vec const& v) 13 | { 14 | return dot(v, v); 15 | } 16 | }; 17 | }//namespace detail 18 | 19 | template 20 | GLM_FUNC_QUALIFIER genType length2(genType x) 21 | { 22 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'length2' accepts only floating-point inputs"); 23 | return x * x; 24 | } 25 | 26 | template 27 | GLM_FUNC_QUALIFIER T length2(vec const& v) 28 | { 29 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'length2' accepts only floating-point inputs"); 30 | return detail::compute_length2::value>::call(v); 31 | } 32 | 33 | template 34 | GLM_FUNC_QUALIFIER T distance2(T p0, T p1) 35 | { 36 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'distance2' accepts only floating-point inputs"); 37 | return length2(p1 - p0); 38 | } 39 | 40 | template 41 | GLM_FUNC_QUALIFIER T distance2(vec const& p0, vec const& p1) 42 | { 43 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'distance2' accepts only floating-point inputs"); 44 | return length2(p1 - p0); 45 | } 46 | 47 | template 48 | GLM_FUNC_QUALIFIER T l1Norm(vec<3, T, Q> const& a, vec<3, T, Q> const& b) 49 | { 50 | return abs(b.x - a.x) + abs(b.y - a.y) + abs(b.z - a.z); 51 | } 52 | 53 | template 54 | GLM_FUNC_QUALIFIER T l1Norm(vec<3, T, Q> const& v) 55 | { 56 | return abs(v.x) + abs(v.y) + abs(v.z); 57 | } 58 | 59 | template 60 | GLM_FUNC_QUALIFIER T l2Norm(vec<3, T, Q> const& a, vec<3, T, Q> const& b 61 | ) 62 | { 63 | return length(b - a); 64 | } 65 | 66 | template 67 | GLM_FUNC_QUALIFIER T l2Norm(vec<3, T, Q> const& v) 68 | { 69 | return length(v); 70 | } 71 | 72 | template 73 | GLM_FUNC_QUALIFIER T lxNorm(vec<3, T, Q> const& x, vec<3, T, Q> const& y, unsigned int Depth) 74 | { 75 | return pow(pow(y.x - x.x, T(Depth)) + pow(y.y - x.y, T(Depth)) + pow(y.z - x.z, T(Depth)), T(1) / T(Depth)); 76 | } 77 | 78 | template 79 | GLM_FUNC_QUALIFIER T lxNorm(vec<3, T, Q> const& v, unsigned int Depth) 80 | { 81 | return pow(pow(v.x, T(Depth)) + pow(v.y, T(Depth)) + pow(v.z, T(Depth)), T(1) / T(Depth)); 82 | } 83 | 84 | }//namespace glm 85 | -------------------------------------------------------------------------------- /deps/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 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_normal extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_normal 30 | /// @{ 31 | 32 | /// Computes triangle normal from triangle points. 33 | /// 34 | /// @see gtx_normal 35 | template 36 | GLM_FUNC_DECL vec<3, T, Q> triangleNormal(vec<3, T, Q> const& p1, vec<3, T, Q> const& p2, vec<3, T, Q> const& p3); 37 | 38 | /// @} 39 | }//namespace glm 40 | 41 | #include "normal.inl" 42 | -------------------------------------------------------------------------------- /deps/glm/gtx/normal.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_normal 2 | /// @file glm/gtx/normal.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER vec<3, T, Q> triangleNormal 8 | ( 9 | vec<3, T, Q> const& p1, 10 | vec<3, T, Q> const& p2, 11 | vec<3, T, Q> const& p3 12 | ) 13 | { 14 | return normalize(cross(p1 - p2, p1 - p3)); 15 | } 16 | }//namespace glm 17 | -------------------------------------------------------------------------------- /deps/glm/gtx/normalize_dot.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_normalize_dot 2 | /// @file glm/gtx/normalize_dot.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_fast_square_root (dependence) 6 | /// 7 | /// @defgroup gtx_normalize_dot GLM_GTX_normalize_dot 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Dot product of vectors that need to be normalize with a single square root. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../gtx/fast_square_root.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_normalize_dot 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 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_normalize_dot extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_normalize_dot 30 | /// @{ 31 | 32 | /// Normalize parameters and returns the dot product of x and y. 33 | /// It's faster that dot(normalize(x), normalize(y)). 34 | /// 35 | /// @see gtx_normalize_dot extension. 36 | template 37 | GLM_FUNC_DECL T normalizeDot(vec const& x, vec const& y); 38 | 39 | /// Normalize parameters and returns the dot product of x and y. 40 | /// Faster that dot(fastNormalize(x), fastNormalize(y)). 41 | /// 42 | /// @see gtx_normalize_dot extension. 43 | template 44 | GLM_FUNC_DECL T fastNormalizeDot(vec const& x, vec const& y); 45 | 46 | /// @} 47 | }//namespace glm 48 | 49 | #include "normalize_dot.inl" 50 | -------------------------------------------------------------------------------- /deps/glm/gtx/normalize_dot.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_normalize_dot 2 | /// @file glm/gtx/normalize_dot.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER T normalizeDot(vec const& x, vec const& y) 8 | { 9 | return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y)); 10 | } 11 | 12 | template 13 | GLM_FUNC_QUALIFIER T fastNormalizeDot(vec const& x, vec const& y) 14 | { 15 | return glm::dot(x, y) * glm::fastInverseSqrt(glm::dot(x, x) * glm::dot(y, y)); 16 | } 17 | }//namespace glm 18 | -------------------------------------------------------------------------------- /deps/glm/gtx/number_precision.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_number_precision 2 | /// @file glm/gtx/number_precision.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_type_precision (dependence) 6 | /// @see gtc_quaternion (dependence) 7 | /// 8 | /// @defgroup gtx_number_precision GLM_GTX_number_precision 9 | /// @ingroup gtx 10 | /// 11 | /// Include to use the features of this extension. 12 | /// 13 | /// Defined size types. 14 | 15 | #pragma once 16 | 17 | // Dependency: 18 | #include "../glm.hpp" 19 | #include "../gtc/type_precision.hpp" 20 | 21 | #ifndef GLM_ENABLE_EXPERIMENTAL 22 | # error "GLM: GLM_GTX_number_precision 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 | #endif 24 | 25 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 26 | # pragma message("GLM: GLM_GTX_number_precision extension included") 27 | #endif 28 | 29 | namespace glm{ 30 | namespace gtx 31 | { 32 | ///////////////////////////// 33 | // Unsigned int vector types 34 | 35 | /// @addtogroup gtx_number_precision 36 | /// @{ 37 | 38 | typedef u8 u8vec1; //!< \brief 8bit unsigned integer scalar. (from GLM_GTX_number_precision extension) 39 | typedef u16 u16vec1; //!< \brief 16bit unsigned integer scalar. (from GLM_GTX_number_precision extension) 40 | typedef u32 u32vec1; //!< \brief 32bit unsigned integer scalar. (from GLM_GTX_number_precision extension) 41 | typedef u64 u64vec1; //!< \brief 64bit unsigned integer scalar. (from GLM_GTX_number_precision extension) 42 | 43 | ////////////////////// 44 | // Float vector types 45 | 46 | typedef f32 f32vec1; //!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) 47 | typedef f64 f64vec1; //!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) 48 | 49 | ////////////////////// 50 | // Float matrix types 51 | 52 | typedef f32 f32mat1; //!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) 53 | typedef f32 f32mat1x1; //!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) 54 | typedef f64 f64mat1; //!< \brief Double-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) 55 | typedef f64 f64mat1x1; //!< \brief Double-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) 56 | 57 | /// @} 58 | }//namespace gtx 59 | }//namespace glm 60 | 61 | #include "number_precision.inl" 62 | -------------------------------------------------------------------------------- /deps/glm/gtx/number_precision.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_number_precision 2 | /// @file glm/gtx/number_precision.inl 3 | 4 | namespace glm 5 | { 6 | 7 | } 8 | -------------------------------------------------------------------------------- /deps/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 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_optimum_pow extension included") 24 | #endif 25 | 26 | namespace glm{ 27 | namespace gtx 28 | { 29 | /// @addtogroup gtx_optimum_pow 30 | /// @{ 31 | 32 | /// Returns x raised to the power of 2. 33 | /// 34 | /// @see gtx_optimum_pow 35 | template 36 | GLM_FUNC_DECL genType pow2(genType const& x); 37 | 38 | /// Returns x raised to the power of 3. 39 | /// 40 | /// @see gtx_optimum_pow 41 | template 42 | GLM_FUNC_DECL genType pow3(genType const& x); 43 | 44 | /// Returns x raised to the power of 4. 45 | /// 46 | /// @see gtx_optimum_pow 47 | template 48 | GLM_FUNC_DECL genType pow4(genType const& x); 49 | 50 | /// @} 51 | }//namespace gtx 52 | }//namespace glm 53 | 54 | #include "optimum_pow.inl" 55 | -------------------------------------------------------------------------------- /deps/glm/gtx/optimum_pow.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_optimum_pow 2 | /// @file glm/gtx/optimum_pow.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER genType pow2(genType const& x) 8 | { 9 | return x * x; 10 | } 11 | 12 | template 13 | GLM_FUNC_QUALIFIER genType pow3(genType const& x) 14 | { 15 | return x * x * x; 16 | } 17 | 18 | template 19 | GLM_FUNC_QUALIFIER genType pow4(genType const& x) 20 | { 21 | return (x * x) * (x * x); 22 | } 23 | }//namespace glm 24 | -------------------------------------------------------------------------------- /deps/glm/gtx/orthonormalize.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_orthonormalize 2 | /// @file glm/gtx/orthonormalize.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_extented_min_max (dependence) 6 | /// 7 | /// @defgroup gtx_orthonormalize GLM_GTX_orthonormalize 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Orthonormalize matrices. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../vec3.hpp" 18 | #include "../mat3x3.hpp" 19 | #include "../geometric.hpp" 20 | 21 | #ifndef GLM_ENABLE_EXPERIMENTAL 22 | # error "GLM: GLM_GTX_orthonormalize 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 | #endif 24 | 25 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 26 | # pragma message("GLM: GLM_GTX_orthonormalize extension included") 27 | #endif 28 | 29 | namespace glm 30 | { 31 | /// @addtogroup gtx_orthonormalize 32 | /// @{ 33 | 34 | /// Returns the orthonormalized matrix of m. 35 | /// 36 | /// @see gtx_orthonormalize 37 | template 38 | GLM_FUNC_DECL mat<3, 3, T, Q> orthonormalize(mat<3, 3, T, Q> const& m); 39 | 40 | /// Orthonormalizes x according y. 41 | /// 42 | /// @see gtx_orthonormalize 43 | template 44 | GLM_FUNC_DECL vec<3, T, Q> orthonormalize(vec<3, T, Q> const& x, vec<3, T, Q> const& y); 45 | 46 | /// @} 47 | }//namespace glm 48 | 49 | #include "orthonormalize.inl" 50 | -------------------------------------------------------------------------------- /deps/glm/gtx/orthonormalize.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_orthonormalize 2 | /// @file glm/gtx/orthonormalize.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER mat<3, 3, T, Q> orthonormalize(mat<3, 3, T, Q> const& m) 8 | { 9 | mat<3, 3, T, Q> r = m; 10 | 11 | r[0] = normalize(r[0]); 12 | 13 | T d0 = dot(r[0], r[1]); 14 | r[1] -= r[0] * d0; 15 | r[1] = normalize(r[1]); 16 | 17 | T d1 = dot(r[1], r[2]); 18 | d0 = dot(r[0], r[2]); 19 | r[2] -= r[0] * d0 + r[1] * d1; 20 | r[2] = normalize(r[2]); 21 | 22 | return r; 23 | } 24 | 25 | template 26 | GLM_FUNC_QUALIFIER vec<3, T, Q> orthonormalize(vec<3, T, Q> const& x, vec<3, T, Q> const& y) 27 | { 28 | return normalize(x - y * dot(y, x)); 29 | } 30 | }//namespace glm 31 | -------------------------------------------------------------------------------- /deps/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 | #endif 23 | 24 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 25 | # pragma message("GLM: GLM_GTX_perpendicular extension included") 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtx_perpendicular 31 | /// @{ 32 | 33 | //! Projects x a perpendicular axis of Normal. 34 | //! From GLM_GTX_perpendicular extension. 35 | template 36 | GLM_FUNC_DECL genType perp(genType const& x, genType const& Normal); 37 | 38 | /// @} 39 | }//namespace glm 40 | 41 | #include "perpendicular.inl" 42 | -------------------------------------------------------------------------------- /deps/glm/gtx/perpendicular.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_perpendicular 2 | /// @file glm/gtx/perpendicular.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER genType perp(genType const& x, genType const& Normal) 8 | { 9 | return x - proj(x, Normal); 10 | } 11 | }//namespace glm 12 | -------------------------------------------------------------------------------- /deps/glm/gtx/polar_coordinates.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_polar_coordinates 2 | /// @file glm/gtx/polar_coordinates.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_polar_coordinates GLM_GTX_polar_coordinates 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Conversion from Euclidean space to polar space and revert. 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_polar_coordinates 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 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_polar_coordinates extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_polar_coordinates 29 | /// @{ 30 | 31 | /// Convert Euclidean to Polar coordinates, x is the xz distance, y, the latitude and z the longitude. 32 | /// 33 | /// @see gtx_polar_coordinates 34 | template 35 | GLM_FUNC_DECL vec<3, T, Q> polar( 36 | vec<3, T, Q> const& euclidean); 37 | 38 | /// Convert Polar to Euclidean coordinates. 39 | /// 40 | /// @see gtx_polar_coordinates 41 | template 42 | GLM_FUNC_DECL vec<3, T, Q> euclidean( 43 | vec<2, T, Q> const& polar); 44 | 45 | /// @} 46 | }//namespace glm 47 | 48 | #include "polar_coordinates.inl" 49 | -------------------------------------------------------------------------------- /deps/glm/gtx/polar_coordinates.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_polar_coordinates 2 | /// @file glm/gtx/polar_coordinates.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER vec<3, T, Q> polar 8 | ( 9 | vec<3, T, Q> const& euclidean 10 | ) 11 | { 12 | T const Length(length(euclidean)); 13 | vec<3, T, Q> const tmp(euclidean / Length); 14 | T const xz_dist(sqrt(tmp.x * tmp.x + tmp.z * tmp.z)); 15 | 16 | return vec<3, T, Q>( 17 | asin(tmp.y), // latitude 18 | atan(tmp.x, tmp.z), // longitude 19 | xz_dist); // xz distance 20 | } 21 | 22 | template 23 | GLM_FUNC_QUALIFIER vec<3, T, Q> euclidean 24 | ( 25 | vec<2, T, Q> const& polar 26 | ) 27 | { 28 | T const latitude(polar.x); 29 | T const longitude(polar.y); 30 | 31 | return vec<3, T, Q>( 32 | cos(latitude) * sin(longitude), 33 | sin(latitude), 34 | cos(latitude) * cos(longitude)); 35 | } 36 | 37 | }//namespace glm 38 | -------------------------------------------------------------------------------- /deps/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 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_projection extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_projection 29 | /// @{ 30 | 31 | /// Projects x on Normal. 32 | /// 33 | /// @see gtx_projection 34 | template 35 | GLM_FUNC_DECL genType proj(genType const& x, genType const& Normal); 36 | 37 | /// @} 38 | }//namespace glm 39 | 40 | #include "projection.inl" 41 | -------------------------------------------------------------------------------- /deps/glm/gtx/projection.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_projection 2 | /// @file glm/gtx/projection.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER genType proj(genType const& x, genType const& Normal) 8 | { 9 | return glm::dot(x, Normal) / glm::dot(Normal, Normal) * Normal; 10 | } 11 | }//namespace glm 12 | -------------------------------------------------------------------------------- /deps/glm/gtx/range.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_range 2 | /// @file glm/gtx/range.hpp 3 | /// @author Joshua Moerman 4 | /// 5 | /// @defgroup gtx_range GLM_GTX_range 6 | /// @ingroup gtx 7 | /// 8 | /// Include to use the features of this extension. 9 | /// 10 | /// Defines begin and end for vectors and matrices. Useful for range-based for loop. 11 | /// The range is defined over the elements, not over columns or rows (e.g. mat4 has 16 elements). 12 | 13 | #pragma once 14 | 15 | // Dependencies 16 | #include "../detail/setup.hpp" 17 | 18 | #ifndef GLM_ENABLE_EXPERIMENTAL 19 | # error "GLM: GLM_GTX_range 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 | #endif 21 | 22 | #if !GLM_HAS_RANGE_FOR 23 | # error "GLM_GTX_range requires C++11 suppport or 'range for'" 24 | #endif 25 | 26 | #include "../gtc/type_ptr.hpp" 27 | #include "../gtc/vec1.hpp" 28 | 29 | namespace glm 30 | { 31 | /// @addtogroup gtx_range 32 | /// @{ 33 | 34 | # if GLM_COMPILER & GLM_COMPILER_VC 35 | # pragma warning(push) 36 | # pragma warning(disable : 4100) // unreferenced formal parameter 37 | # endif 38 | 39 | template 40 | inline length_t components(vec<1, T, Q> const& v) 41 | { 42 | return v.length(); 43 | } 44 | 45 | template 46 | inline length_t components(vec<2, T, Q> const& v) 47 | { 48 | return v.length(); 49 | } 50 | 51 | template 52 | inline length_t components(vec<3, T, Q> const& v) 53 | { 54 | return v.length(); 55 | } 56 | 57 | template 58 | inline length_t components(vec<4, T, Q> const& v) 59 | { 60 | return v.length(); 61 | } 62 | 63 | template 64 | inline length_t components(genType const& m) 65 | { 66 | return m.length() * m[0].length(); 67 | } 68 | 69 | template 70 | inline typename genType::value_type const * begin(genType const& v) 71 | { 72 | return value_ptr(v); 73 | } 74 | 75 | template 76 | inline typename genType::value_type const * end(genType const& v) 77 | { 78 | return begin(v) + components(v); 79 | } 80 | 81 | template 82 | inline typename genType::value_type * begin(genType& v) 83 | { 84 | return value_ptr(v); 85 | } 86 | 87 | template 88 | inline typename genType::value_type * end(genType& v) 89 | { 90 | return begin(v) + components(v); 91 | } 92 | 93 | # if GLM_COMPILER & GLM_COMPILER_VC 94 | # pragma warning(pop) 95 | # endif 96 | 97 | /// @} 98 | }//namespace glm 99 | -------------------------------------------------------------------------------- /deps/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 "../detail/setup.hpp" 17 | #include "../detail/type_int.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 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_raw_data extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_raw_data 30 | /// @{ 31 | 32 | //! Type for byte numbers. 33 | //! From GLM_GTX_raw_data extension. 34 | typedef detail::uint8 byte; 35 | 36 | //! Type for word numbers. 37 | //! From GLM_GTX_raw_data extension. 38 | typedef detail::uint16 word; 39 | 40 | //! Type for dword numbers. 41 | //! From GLM_GTX_raw_data extension. 42 | typedef detail::uint32 dword; 43 | 44 | //! Type for qword numbers. 45 | //! From GLM_GTX_raw_data extension. 46 | typedef detail::uint64 qword; 47 | 48 | /// @} 49 | }// namespace glm 50 | 51 | #include "raw_data.inl" 52 | -------------------------------------------------------------------------------- /deps/glm/gtx/raw_data.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_raw_data 2 | /// @file glm/gtx/raw_data.inl 3 | -------------------------------------------------------------------------------- /deps/glm/gtx/rotate_normalized_axis.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_rotate_normalized_axis 2 | /// @file glm/gtx/rotate_normalized_axis.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_matrix_transform 6 | /// @see gtc_quaternion 7 | /// 8 | /// @defgroup gtx_rotate_normalized_axis GLM_GTX_rotate_normalized_axis 9 | /// @ingroup gtx 10 | /// 11 | /// Include to use the features of this extension. 12 | /// 13 | /// Quaternions and matrices rotations around normalized axis. 14 | 15 | #pragma once 16 | 17 | // Dependency: 18 | #include "../glm.hpp" 19 | #include "../gtc/epsilon.hpp" 20 | #include "../gtc/quaternion.hpp" 21 | 22 | #ifndef GLM_ENABLE_EXPERIMENTAL 23 | # error "GLM: GLM_GTX_rotate_normalized_axis is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 24 | #endif 25 | 26 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 27 | # pragma message("GLM: GLM_GTX_rotate_normalized_axis extension included") 28 | #endif 29 | 30 | namespace glm 31 | { 32 | /// @addtogroup gtx_rotate_normalized_axis 33 | /// @{ 34 | 35 | /// Builds a rotation 4 * 4 matrix created from a normalized axis and an angle. 36 | /// 37 | /// @param m Input matrix multiplied by this rotation matrix. 38 | /// @param angle Rotation angle expressed in radians. 39 | /// @param axis Rotation axis, must be normalized. 40 | /// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double. 41 | /// 42 | /// @see gtx_rotate_normalized_axis 43 | /// @see - rotate(T angle, T x, T y, T z) 44 | /// @see - rotate(mat<4, 4, T, Q> const& m, T angle, T x, T y, T z) 45 | /// @see - rotate(T angle, vec<3, T, Q> const& v) 46 | template 47 | GLM_FUNC_DECL mat<4, 4, T, Q> rotateNormalizedAxis( 48 | mat<4, 4, T, Q> const& m, 49 | T const& angle, 50 | vec<3, T, Q> const& axis); 51 | 52 | /// Rotates a quaternion from a vector of 3 components normalized axis and an angle. 53 | /// 54 | /// @param q Source orientation 55 | /// @param angle Angle expressed in radians. 56 | /// @param axis Normalized axis of the rotation, must be normalized. 57 | /// 58 | /// @see gtx_rotate_normalized_axis 59 | template 60 | GLM_FUNC_DECL tquat rotateNormalizedAxis( 61 | tquat const& q, 62 | T const& angle, 63 | vec<3, T, Q> const& axis); 64 | 65 | /// @} 66 | }//namespace glm 67 | 68 | #include "rotate_normalized_axis.inl" 69 | -------------------------------------------------------------------------------- /deps/glm/gtx/rotate_normalized_axis.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_rotate_normalized_axis 2 | /// @file glm/gtx/rotate_normalized_axis.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rotateNormalizedAxis 8 | ( 9 | mat<4, 4, T, Q> const& m, 10 | T const& angle, 11 | vec<3, T, Q> const& v 12 | ) 13 | { 14 | T const a = angle; 15 | T const c = cos(a); 16 | T const s = sin(a); 17 | 18 | vec<3, T, Q> const axis(v); 19 | 20 | vec<3, T, Q> const temp((static_cast(1) - c) * axis); 21 | 22 | mat<4, 4, T, Q> Rotate; 23 | Rotate[0][0] = c + temp[0] * axis[0]; 24 | Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2]; 25 | Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1]; 26 | 27 | Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2]; 28 | Rotate[1][1] = c + temp[1] * axis[1]; 29 | Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0]; 30 | 31 | Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1]; 32 | Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0]; 33 | Rotate[2][2] = c + temp[2] * axis[2]; 34 | 35 | mat<4, 4, T, Q> Result; 36 | Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2]; 37 | Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2]; 38 | Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2]; 39 | Result[3] = m[3]; 40 | return Result; 41 | } 42 | 43 | template 44 | GLM_FUNC_QUALIFIER tquat rotateNormalizedAxis 45 | ( 46 | tquat const& q, 47 | T const& angle, 48 | vec<3, T, Q> const& v 49 | ) 50 | { 51 | vec<3, T, Q> const Tmp(v); 52 | 53 | T const AngleRad(angle); 54 | T const Sin = sin(AngleRad * T(0.5)); 55 | 56 | return q * tquat(cos(AngleRad * static_cast(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin); 57 | //return gtc::quaternion::cross(q, tquat(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin)); 58 | } 59 | }//namespace glm 60 | -------------------------------------------------------------------------------- /deps/glm/gtx/scalar_multiplication.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx 2 | /// @file glm/gtx/scalar_multiplication.hpp 3 | /// @author Joshua Moerman 4 | /// 5 | /// Include to use the features of this extension. 6 | /// 7 | /// Enables scalar multiplication for all types 8 | /// 9 | /// Since GLSL is very strict about types, the following (often used) combinations do not work: 10 | /// double * vec4 11 | /// int * vec4 12 | /// vec4 / int 13 | /// So we'll fix that! Of course "float * vec4" should remain the same (hence the enable_if magic) 14 | 15 | #pragma once 16 | 17 | #include "../detail/setup.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_scalar_multiplication 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 | #endif 22 | 23 | #if !GLM_HAS_TEMPLATE_ALIASES && !(GLM_COMPILER & GLM_COMPILER_GCC) 24 | # error "GLM_GTX_scalar_multiplication requires C++11 support or alias templates and if not support for GCC" 25 | #endif 26 | 27 | #include "../vec2.hpp" 28 | #include "../vec3.hpp" 29 | #include "../vec4.hpp" 30 | #include "../mat2x2.hpp" 31 | #include 32 | 33 | namespace glm 34 | { 35 | template 36 | using return_type_scalar_multiplication = typename std::enable_if< 37 | !std::is_same::value // T may not be a float 38 | && std::is_arithmetic::value, Vec // But it may be an int or double (no vec3 or mat3, ...) 39 | >::type; 40 | 41 | #define GLM_IMPLEMENT_SCAL_MULT(Vec) \ 42 | template \ 43 | return_type_scalar_multiplication \ 44 | operator*(T const& s, Vec rh){ \ 45 | return rh *= static_cast(s); \ 46 | } \ 47 | \ 48 | template \ 49 | return_type_scalar_multiplication \ 50 | operator*(Vec lh, T const& s){ \ 51 | return lh *= static_cast(s); \ 52 | } \ 53 | \ 54 | template \ 55 | return_type_scalar_multiplication \ 56 | operator/(Vec lh, T const& s){ \ 57 | return lh *= 1.0f / s; \ 58 | } 59 | 60 | GLM_IMPLEMENT_SCAL_MULT(vec2) 61 | GLM_IMPLEMENT_SCAL_MULT(vec3) 62 | GLM_IMPLEMENT_SCAL_MULT(vec4) 63 | 64 | GLM_IMPLEMENT_SCAL_MULT(mat2) 65 | GLM_IMPLEMENT_SCAL_MULT(mat2x3) 66 | GLM_IMPLEMENT_SCAL_MULT(mat2x4) 67 | GLM_IMPLEMENT_SCAL_MULT(mat3x2) 68 | GLM_IMPLEMENT_SCAL_MULT(mat3) 69 | GLM_IMPLEMENT_SCAL_MULT(mat3x4) 70 | GLM_IMPLEMENT_SCAL_MULT(mat4x2) 71 | GLM_IMPLEMENT_SCAL_MULT(mat4x3) 72 | GLM_IMPLEMENT_SCAL_MULT(mat4) 73 | 74 | #undef GLM_IMPLEMENT_SCAL_MULT 75 | } // namespace glm 76 | -------------------------------------------------------------------------------- /deps/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_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 | #endif 21 | 22 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 23 | # pragma message("GLM: GLM_GTX_extend extension included") 24 | #endif 25 | 26 | namespace glm 27 | { 28 | /// @addtogroup gtx_scalar_relational 29 | /// @{ 30 | 31 | 32 | 33 | /// @} 34 | }//namespace glm 35 | 36 | #include "scalar_relational.inl" 37 | -------------------------------------------------------------------------------- /deps/glm/gtx/scalar_relational.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_scalar_relational 2 | /// @file glm/gtx/scalar_relational.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER bool lessThan 8 | ( 9 | T const& x, 10 | T const& y 11 | ) 12 | { 13 | return x < y; 14 | } 15 | 16 | template 17 | GLM_FUNC_QUALIFIER bool lessThanEqual 18 | ( 19 | T const& x, 20 | T const& y 21 | ) 22 | { 23 | return x <= y; 24 | } 25 | 26 | template 27 | GLM_FUNC_QUALIFIER bool greaterThan 28 | ( 29 | T const& x, 30 | T const& y 31 | ) 32 | { 33 | return x > y; 34 | } 35 | 36 | template 37 | GLM_FUNC_QUALIFIER bool greaterThanEqual 38 | ( 39 | T const& x, 40 | T const& y 41 | ) 42 | { 43 | return x >= y; 44 | } 45 | 46 | template 47 | GLM_FUNC_QUALIFIER bool equal 48 | ( 49 | T const& x, 50 | T const& y 51 | ) 52 | { 53 | return detail::compute_equal::call(x, y); 54 | } 55 | 56 | template 57 | GLM_FUNC_QUALIFIER bool notEqual 58 | ( 59 | T const& x, 60 | T const& y 61 | ) 62 | { 63 | return !detail::compute_equal::call(x, y); 64 | } 65 | 66 | GLM_FUNC_QUALIFIER bool any 67 | ( 68 | bool const& x 69 | ) 70 | { 71 | return x; 72 | } 73 | 74 | GLM_FUNC_QUALIFIER bool all 75 | ( 76 | bool const& x 77 | ) 78 | { 79 | return x; 80 | } 81 | 82 | GLM_FUNC_QUALIFIER bool not_ 83 | ( 84 | bool const& x 85 | ) 86 | { 87 | return !x; 88 | } 89 | }//namespace glm 90 | -------------------------------------------------------------------------------- /deps/glm/gtx/spline.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_spline 2 | /// @file glm/gtx/spline.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_spline GLM_GTX_spline 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Spline functions 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | #include "../gtx/optimum_pow.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # error "GLM: GLM_GTX_spline 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 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 24 | # pragma message("GLM: GLM_GTX_spline extension included") 25 | #endif 26 | 27 | namespace glm 28 | { 29 | /// @addtogroup gtx_spline 30 | /// @{ 31 | 32 | /// Return a point from a catmull rom curve. 33 | /// @see gtx_spline extension. 34 | template 35 | GLM_FUNC_DECL genType catmullRom( 36 | genType const& v1, 37 | genType const& v2, 38 | genType const& v3, 39 | genType const& v4, 40 | typename genType::value_type const& s); 41 | 42 | /// Return a point from a hermite curve. 43 | /// @see gtx_spline extension. 44 | template 45 | GLM_FUNC_DECL genType hermite( 46 | genType const& v1, 47 | genType const& t1, 48 | genType const& v2, 49 | genType const& t2, 50 | typename genType::value_type const& s); 51 | 52 | /// Return a point from a cubic curve. 53 | /// @see gtx_spline extension. 54 | template 55 | GLM_FUNC_DECL genType cubic( 56 | genType const& v1, 57 | genType const& v2, 58 | genType const& v3, 59 | genType const& v4, 60 | typename genType::value_type const& s); 61 | 62 | /// @} 63 | }//namespace glm 64 | 65 | #include "spline.inl" 66 | -------------------------------------------------------------------------------- /deps/glm/gtx/spline.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_spline 2 | /// @file glm/gtx/spline.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER genType catmullRom 8 | ( 9 | genType const& v1, 10 | genType const& v2, 11 | genType const& v3, 12 | genType const& v4, 13 | typename genType::value_type const& s 14 | ) 15 | { 16 | typename genType::value_type s2 = pow2(s); 17 | typename genType::value_type s3 = pow3(s); 18 | 19 | typename genType::value_type f1 = -s3 + typename genType::value_type(2) * s2 - s; 20 | typename genType::value_type f2 = typename genType::value_type(3) * s3 - typename genType::value_type(5) * s2 + typename genType::value_type(2); 21 | typename genType::value_type f3 = typename genType::value_type(-3) * s3 + typename genType::value_type(4) * s2 + s; 22 | typename genType::value_type f4 = s3 - s2; 23 | 24 | return (f1 * v1 + f2 * v2 + f3 * v3 + f4 * v4) / typename genType::value_type(2); 25 | 26 | } 27 | 28 | template 29 | GLM_FUNC_QUALIFIER genType hermite 30 | ( 31 | genType const& v1, 32 | genType const& t1, 33 | genType const& v2, 34 | genType const& t2, 35 | typename genType::value_type const& s 36 | ) 37 | { 38 | typename genType::value_type s2 = pow2(s); 39 | typename genType::value_type s3 = pow3(s); 40 | 41 | typename genType::value_type f1 = typename genType::value_type(2) * s3 - typename genType::value_type(3) * s2 + typename genType::value_type(1); 42 | typename genType::value_type f2 = typename genType::value_type(-2) * s3 + typename genType::value_type(3) * s2; 43 | typename genType::value_type f3 = s3 - typename genType::value_type(2) * s2 + s; 44 | typename genType::value_type f4 = s3 - s2; 45 | 46 | return f1 * v1 + f2 * v2 + f3 * t1 + f4 * t2; 47 | } 48 | 49 | template 50 | GLM_FUNC_QUALIFIER genType cubic 51 | ( 52 | genType const& v1, 53 | genType const& v2, 54 | genType const& v3, 55 | genType const& v4, 56 | typename genType::value_type const& s 57 | ) 58 | { 59 | return ((v1 * s + v2) * s + v3) * s + v4; 60 | } 61 | }//namespace glm 62 | -------------------------------------------------------------------------------- /deps/glm/gtx/std_based_type.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_std_based_type 2 | /// @file glm/gtx/std_based_type.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_extented_min_max (dependence) 6 | /// 7 | /// @defgroup gtx_std_based_type GLM_GTX_std_based_type 8 | /// @ingroup gtx 9 | /// 10 | /// Include to use the features of this extension. 11 | /// 12 | /// Adds vector types based on STL value types. 13 | 14 | #pragma once 15 | 16 | // Dependency: 17 | #include "../glm.hpp" 18 | #include 19 | 20 | #ifndef GLM_ENABLE_EXPERIMENTAL 21 | # error "GLM: GLM_GTX_std_based_type 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 | #endif 23 | 24 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 25 | # pragma message("GLM: GLM_GTX_std_based_type extension included") 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtx_std_based_type 31 | /// @{ 32 | 33 | /// Vector type based of one std::size_t component. 34 | /// @see GLM_GTX_std_based_type 35 | typedef vec<1, std::size_t, defaultp> size1; 36 | 37 | /// Vector type based of two std::size_t components. 38 | /// @see GLM_GTX_std_based_type 39 | typedef vec<2, std::size_t, defaultp> size2; 40 | 41 | /// Vector type based of three std::size_t components. 42 | /// @see GLM_GTX_std_based_type 43 | typedef vec<3, std::size_t, defaultp> size3; 44 | 45 | /// Vector type based of four std::size_t components. 46 | /// @see GLM_GTX_std_based_type 47 | typedef vec<4, std::size_t, defaultp> size4; 48 | 49 | /// Vector type based of one std::size_t component. 50 | /// @see GLM_GTX_std_based_type 51 | typedef vec<1, std::size_t, defaultp> size1_t; 52 | 53 | /// Vector type based of two std::size_t components. 54 | /// @see GLM_GTX_std_based_type 55 | typedef vec<2, std::size_t, defaultp> size2_t; 56 | 57 | /// Vector type based of three std::size_t components. 58 | /// @see GLM_GTX_std_based_type 59 | typedef vec<3, std::size_t, defaultp> size3_t; 60 | 61 | /// Vector type based of four std::size_t components. 62 | /// @see GLM_GTX_std_based_type 63 | typedef vec<4, std::size_t, defaultp> size4_t; 64 | 65 | /// @} 66 | }//namespace glm 67 | 68 | #include "std_based_type.inl" 69 | -------------------------------------------------------------------------------- /deps/glm/gtx/std_based_type.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_std_based_type 2 | /// @file glm/gtx/std_based_type.inl 3 | 4 | namespace glm 5 | { 6 | 7 | } 8 | -------------------------------------------------------------------------------- /deps/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 | /// This extension is not supported with CUDA 16 | 17 | #pragma once 18 | 19 | // Dependency: 20 | #include "../glm.hpp" 21 | #include "../gtc/type_precision.hpp" 22 | #include "../gtc/quaternion.hpp" 23 | #include "../gtx/dual_quaternion.hpp" 24 | #include 25 | #include 26 | 27 | #ifndef GLM_ENABLE_EXPERIMENTAL 28 | # 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." 29 | #endif 30 | 31 | #if(GLM_COMPILER & GLM_COMPILER_CUDA) 32 | # error "GLM_GTX_string_cast is not supported on CUDA compiler" 33 | #endif 34 | 35 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 36 | # pragma message("GLM: GLM_GTX_string_cast extension included") 37 | #endif 38 | 39 | namespace glm 40 | { 41 | /// @addtogroup gtx_string_cast 42 | /// @{ 43 | 44 | /// Create a string from a GLM vector or matrix typed variable. 45 | /// @see gtx_string_cast extension. 46 | template 47 | GLM_FUNC_DECL std::string to_string(genType const& x); 48 | 49 | /// @} 50 | }//namespace glm 51 | 52 | #include "string_cast.inl" 53 | -------------------------------------------------------------------------------- /deps/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 | #endif 23 | 24 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 25 | # pragma message("GLM: GLM_GTX_texture extension included") 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtx_texture 31 | /// @{ 32 | 33 | /// Compute the number of mipmaps levels necessary to create a mipmap complete texture 34 | /// 35 | /// @param Extent Extent of the texture base level mipmap 36 | /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector 37 | /// @tparam T Floating-point or signed integer scalar types 38 | /// @tparam Q Value from qualifier enum 39 | template 40 | T levels(vec const& Extent); 41 | 42 | /// @} 43 | }// namespace glm 44 | 45 | #include "texture.inl" 46 | 47 | -------------------------------------------------------------------------------- /deps/glm/gtx/texture.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_texture 2 | /// @file glm/gtx/texture.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | inline T levels(vec const& Extent) 8 | { 9 | return glm::log2(compMax(Extent)) + static_cast(1); 10 | } 11 | 12 | template 13 | inline T levels(T Extent) 14 | { 15 | return vec<1, T, defaultp>(Extent).x; 16 | } 17 | }//namespace glm 18 | 19 | -------------------------------------------------------------------------------- /deps/glm/gtx/transform.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_transform 2 | /// @file glm/gtx/transform.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtc_matrix_transform (dependence) 6 | /// @see gtx_transform 7 | /// @see gtx_transform2 8 | /// 9 | /// @defgroup gtx_transform GLM_GTX_transform 10 | /// @ingroup gtx 11 | /// 12 | /// Include to use the features of this extension. 13 | /// 14 | /// Add transformation matrices 15 | 16 | #pragma once 17 | 18 | // Dependency: 19 | #include "../glm.hpp" 20 | #include "../gtc/matrix_transform.hpp" 21 | 22 | #ifndef GLM_ENABLE_EXPERIMENTAL 23 | # error "GLM: GLM_GTX_transform is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 24 | #endif 25 | 26 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 27 | # pragma message("GLM: GLM_GTX_transform extension included") 28 | #endif 29 | 30 | namespace glm 31 | { 32 | /// @addtogroup gtx_transform 33 | /// @{ 34 | 35 | /// Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars. 36 | /// @see gtc_matrix_transform 37 | /// @see gtx_transform 38 | template 39 | GLM_FUNC_DECL mat<4, 4, T, Q> translate( 40 | vec<3, T, Q> const& v); 41 | 42 | /// Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in radians. 43 | /// @see gtc_matrix_transform 44 | /// @see gtx_transform 45 | template 46 | GLM_FUNC_DECL mat<4, 4, T, Q> rotate( 47 | T angle, 48 | vec<3, T, Q> const& v); 49 | 50 | /// Transforms a matrix with a scale 4 * 4 matrix created from a vector of 3 components. 51 | /// @see gtc_matrix_transform 52 | /// @see gtx_transform 53 | template 54 | GLM_FUNC_DECL mat<4, 4, T, Q> scale( 55 | vec<3, T, Q> const& v); 56 | 57 | /// @} 58 | }// namespace glm 59 | 60 | #include "transform.inl" 61 | -------------------------------------------------------------------------------- /deps/glm/gtx/transform.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_transform 2 | /// @file glm/gtx/transform.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> translate(vec<3, T, Q> const& v) 8 | { 9 | return translate(mat<4, 4, T, Q>(static_cast(1)), v); 10 | } 11 | 12 | template 13 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> rotate(T angle, vec<3, T, Q> const& v) 14 | { 15 | return rotate(mat<4, 4, T, Q>(static_cast(1)), angle, v); 16 | } 17 | 18 | template 19 | GLM_FUNC_QUALIFIER mat<4, 4, T, Q> scale(vec<3, T, Q> const& v) 20 | { 21 | return scale(mat<4, 4, T, Q>(static_cast(1)), v); 22 | } 23 | 24 | }//namespace glm 25 | -------------------------------------------------------------------------------- /deps/glm/gtx/type_aligned.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtc_type_aligned 2 | /// @file glm/gtc/type_aligned.inl 3 | 4 | namespace glm 5 | { 6 | 7 | } 8 | -------------------------------------------------------------------------------- /deps/glm/gtx/type_trait.inl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/deps/glm/gtx/type_trait.inl -------------------------------------------------------------------------------- /deps/glm/gtx/vector_angle.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_vector_angle 2 | /// @file glm/gtx/vector_angle.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// @see gtx_quaternion (dependence) 6 | /// @see gtx_epsilon (dependence) 7 | /// 8 | /// @defgroup gtx_vector_angle GLM_GTX_vector_angle 9 | /// @ingroup gtx 10 | /// 11 | /// Include to use the features of this extension. 12 | /// 13 | /// Compute angle between vectors 14 | 15 | #pragma once 16 | 17 | // Dependency: 18 | #include "../glm.hpp" 19 | #include "../gtc/epsilon.hpp" 20 | #include "../gtx/quaternion.hpp" 21 | #include "../gtx/rotate_vector.hpp" 22 | 23 | #ifndef GLM_ENABLE_EXPERIMENTAL 24 | # error "GLM: GLM_GTX_vector_angle 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." 25 | #endif 26 | 27 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 28 | # pragma message("GLM: GLM_GTX_vector_angle extension included") 29 | #endif 30 | 31 | namespace glm 32 | { 33 | /// @addtogroup gtx_vector_angle 34 | /// @{ 35 | 36 | //! Returns the absolute angle between two vectors. 37 | //! Parameters need to be normalized. 38 | /// @see gtx_vector_angle extension. 39 | template 40 | GLM_FUNC_DECL T angle(vec const& x, vec const& y); 41 | 42 | //! Returns the oriented angle between two 2d vectors. 43 | //! Parameters need to be normalized. 44 | /// @see gtx_vector_angle extension. 45 | template 46 | GLM_FUNC_DECL T orientedAngle(vec<2, T, Q> const& x, vec<2, T, Q> const& y); 47 | 48 | //! Returns the oriented angle between two 3d vectors based from a reference axis. 49 | //! Parameters need to be normalized. 50 | /// @see gtx_vector_angle extension. 51 | template 52 | GLM_FUNC_DECL T orientedAngle(vec<3, T, Q> const& x, vec<3, T, Q> const& y, vec<3, T, Q> const& ref); 53 | 54 | /// @} 55 | }// namespace glm 56 | 57 | #include "vector_angle.inl" 58 | -------------------------------------------------------------------------------- /deps/glm/gtx/vector_angle.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_vector_angle 2 | /// @file glm/gtx/vector_angle.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER genType angle 8 | ( 9 | genType const& x, 10 | genType const& y 11 | ) 12 | { 13 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'angle' only accept floating-point inputs"); 14 | return acos(clamp(dot(x, y), genType(-1), genType(1))); 15 | } 16 | 17 | template 18 | GLM_FUNC_QUALIFIER T angle(vec const& x, vec const& y) 19 | { 20 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'angle' only accept floating-point inputs"); 21 | return acos(clamp(dot(x, y), T(-1), T(1))); 22 | } 23 | 24 | //! \todo epsilon is hard coded to 0.01 25 | template 26 | GLM_FUNC_QUALIFIER T orientedAngle(vec<2, T, Q> const& x, vec<2, T, Q> const& y) 27 | { 28 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'orientedAngle' only accept floating-point inputs"); 29 | T const Angle(acos(clamp(dot(x, y), T(-1), T(1)))); 30 | 31 | if(all(epsilonEqual(y, glm::rotate(x, Angle), T(0.0001)))) 32 | return Angle; 33 | else 34 | return -Angle; 35 | } 36 | 37 | template 38 | GLM_FUNC_QUALIFIER T orientedAngle(vec<3, T, Q> const& x, vec<3, T, Q> const& y, vec<3, T, Q> const& ref) 39 | { 40 | GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'orientedAngle' only accept floating-point inputs"); 41 | 42 | T const Angle(acos(clamp(dot(x, y), T(-1), T(1)))); 43 | return mix(Angle, -Angle, dot(ref, cross(x, y)) < T(0)); 44 | } 45 | }//namespace glm 46 | -------------------------------------------------------------------------------- /deps/glm/gtx/vector_query.hpp: -------------------------------------------------------------------------------- 1 | /// @ref gtx_vector_query 2 | /// @file glm/gtx/vector_query.hpp 3 | /// 4 | /// @see core (dependence) 5 | /// 6 | /// @defgroup gtx_vector_query GLM_GTX_vector_query 7 | /// @ingroup gtx 8 | /// 9 | /// Include to use the features of this extension. 10 | /// 11 | /// Query informations of vector types 12 | 13 | #pragma once 14 | 15 | // Dependency: 16 | #include "../glm.hpp" 17 | #include 18 | #include 19 | 20 | #ifndef GLM_ENABLE_EXPERIMENTAL 21 | # error "GLM: GLM_GTX_vector_query 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 | #endif 23 | 24 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) 25 | # pragma message("GLM: GLM_GTX_vector_query extension included") 26 | #endif 27 | 28 | namespace glm 29 | { 30 | /// @addtogroup gtx_vector_query 31 | /// @{ 32 | 33 | //! Check whether two vectors are collinears. 34 | /// @see gtx_vector_query extensions. 35 | template 36 | GLM_FUNC_DECL bool areCollinear(vec const& v0, vec const& v1, T const& epsilon); 37 | 38 | //! Check whether two vectors are orthogonals. 39 | /// @see gtx_vector_query extensions. 40 | template 41 | GLM_FUNC_DECL bool areOrthogonal(vec const& v0, vec const& v1, T const& epsilon); 42 | 43 | //! Check whether a vector is normalized. 44 | /// @see gtx_vector_query extensions. 45 | template 46 | GLM_FUNC_DECL bool isNormalized(vec const& v, T const& epsilon); 47 | 48 | //! Check whether a vector is null. 49 | /// @see gtx_vector_query extensions. 50 | template 51 | GLM_FUNC_DECL bool isNull(vec const& v, T const& epsilon); 52 | 53 | //! Check whether a each component of a vector is null. 54 | /// @see gtx_vector_query extensions. 55 | template 56 | GLM_FUNC_DECL vec isCompNull(vec const& v, T const& epsilon); 57 | 58 | //! Check whether two vectors are orthonormal. 59 | /// @see gtx_vector_query extensions. 60 | template 61 | GLM_FUNC_DECL bool areOrthonormal(vec const& v0, vec const& v1, T const& epsilon); 62 | 63 | /// @} 64 | }// namespace glm 65 | 66 | #include "vector_query.inl" 67 | -------------------------------------------------------------------------------- /deps/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 "../gtc/vec1.hpp" 18 | 19 | #ifndef GLM_ENABLE_EXPERIMENTAL 20 | # 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." 21 | #endif 22 | 23 | #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !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 | /// Simulate GL_CLAMP OpenGL wrap mode 33 | /// @see gtx_wrap extension. 34 | template 35 | GLM_FUNC_DECL genType clamp(genType const& Texcoord); 36 | 37 | /// Simulate GL_REPEAT OpenGL wrap mode 38 | /// @see gtx_wrap extension. 39 | template 40 | GLM_FUNC_DECL genType repeat(genType const& Texcoord); 41 | 42 | /// Simulate GL_MIRRORED_REPEAT OpenGL wrap mode 43 | /// @see gtx_wrap extension. 44 | template 45 | GLM_FUNC_DECL genType mirrorClamp(genType const& Texcoord); 46 | 47 | /// Simulate GL_MIRROR_REPEAT OpenGL wrap mode 48 | /// @see gtx_wrap extension. 49 | template 50 | GLM_FUNC_DECL genType mirrorRepeat(genType const& Texcoord); 51 | 52 | /// @} 53 | }// namespace glm 54 | 55 | #include "wrap.inl" 56 | -------------------------------------------------------------------------------- /deps/glm/gtx/wrap.inl: -------------------------------------------------------------------------------- 1 | /// @ref gtx_wrap 2 | /// @file glm/gtx/wrap.inl 3 | 4 | namespace glm 5 | { 6 | template 7 | GLM_FUNC_QUALIFIER vec clamp(vec const& Texcoord) 8 | { 9 | return glm::clamp(Texcoord, vec(0), vec(1)); 10 | } 11 | 12 | template 13 | GLM_FUNC_QUALIFIER genType clamp(genType const& Texcoord) 14 | { 15 | return clamp(vec<1, genType, defaultp>(Texcoord)).x; 16 | } 17 | 18 | template 19 | GLM_FUNC_QUALIFIER vec repeat(vec const& Texcoord) 20 | { 21 | return glm::fract(Texcoord); 22 | } 23 | 24 | template 25 | GLM_FUNC_QUALIFIER genType repeat(genType const& Texcoord) 26 | { 27 | return repeat(vec<1, genType, defaultp>(Texcoord)).x; 28 | } 29 | 30 | template 31 | GLM_FUNC_QUALIFIER vec mirrorClamp(vec const& Texcoord) 32 | { 33 | return glm::fract(glm::abs(Texcoord)); 34 | } 35 | 36 | template 37 | GLM_FUNC_QUALIFIER genType mirrorClamp(genType const& Texcoord) 38 | { 39 | return mirrorClamp(vec<1, genType, defaultp>(Texcoord)).x; 40 | } 41 | 42 | template 43 | GLM_FUNC_QUALIFIER vec mirrorRepeat(vec const& Texcoord) 44 | { 45 | vec const Abs = glm::abs(Texcoord); 46 | vec const Clamp = glm::mod(glm::floor(Abs), vec(2)); 47 | vec const Floor = glm::floor(Abs); 48 | vec const Rest = Abs - Floor; 49 | vec const Mirror = Clamp + Rest; 50 | return mix(Rest, vec(1) - Rest, glm::greaterThanEqual(Mirror, vec(1))); 51 | } 52 | 53 | template 54 | GLM_FUNC_QUALIFIER genType mirrorRepeat(genType const& Texcoord) 55 | { 56 | return mirrorRepeat(vec<1, genType, defaultp>(Texcoord)).x; 57 | } 58 | }//namespace glm 59 | -------------------------------------------------------------------------------- /deps/glm/mat2x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat2x2.hpp 3 | 4 | #include "detail/setup.hpp" 5 | 6 | #pragma once 7 | 8 | #include "detail/type_mat2x2.hpp" 9 | 10 | namespace glm 11 | { 12 | /// 2 columns of 2 components matrix of low qualifier floating-point numbers. 13 | /// There is no guarantee on the actual qualifier. 14 | /// 15 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 16 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 17 | typedef mat<2, 2, float, lowp> lowp_mat2; 18 | 19 | /// 2 columns of 2 components matrix of medium qualifier floating-point numbers. 20 | /// There is no guarantee on the actual qualifier. 21 | /// 22 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 23 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 24 | typedef mat<2, 2, float, mediump> mediump_mat2; 25 | 26 | /// 2 columns of 2 components matrix of high qualifier floating-point numbers. 27 | /// There is no guarantee on the actual qualifier. 28 | /// 29 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 30 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 31 | typedef mat<2, 2, float, highp> highp_mat2; 32 | 33 | /// 2 columns of 2 components matrix of low qualifier floating-point numbers. 34 | /// There is no guarantee on the actual qualifier. 35 | /// 36 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 37 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 38 | typedef mat<2, 2, float, lowp> lowp_mat2x2; 39 | 40 | /// 2 columns of 2 components matrix of medium qualifier floating-point numbers. 41 | /// There is no guarantee on the actual qualifier. 42 | /// 43 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 44 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 45 | typedef mat<2, 2, float, mediump> mediump_mat2x2; 46 | 47 | /// 2 columns of 2 components matrix of high qualifier floating-point numbers. 48 | /// There is no guarantee on the actual qualifier. 49 | /// 50 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 51 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 52 | typedef mat<2, 2, float, highp> highp_mat2x2; 53 | 54 | }//namespace glm 55 | -------------------------------------------------------------------------------- /deps/glm/mat2x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat2x3.hpp 3 | 4 | #include "detail/setup.hpp" 5 | 6 | #pragma once 7 | 8 | #include "detail/type_mat2x3.hpp" 9 | 10 | namespace glm 11 | { 12 | /// 2 columns of 3 components matrix of low qualifier floating-point numbers. 13 | /// There is no guarantee on the actual qualifier. 14 | /// 15 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 16 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 17 | typedef mat<2, 3, float, lowp> lowp_mat2x3; 18 | 19 | /// 2 columns of 3 components matrix of medium qualifier floating-point numbers. 20 | /// There is no guarantee on the actual qualifier. 21 | /// 22 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 23 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 24 | typedef mat<2, 3, float, mediump> mediump_mat2x3; 25 | 26 | /// 2 columns of 3 components matrix of high qualifier floating-point numbers. 27 | /// There is no guarantee on the actual qualifier. 28 | /// 29 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 30 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 31 | typedef mat<2, 3, float, highp> highp_mat2x3; 32 | 33 | }//namespace glm 34 | 35 | -------------------------------------------------------------------------------- /deps/glm/mat2x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat2x4.hpp 3 | 4 | #include "detail/setup.hpp" 5 | 6 | #pragma once 7 | 8 | #include "detail/type_mat2x4.hpp" 9 | 10 | namespace glm 11 | { 12 | /// 2 columns of 4 components matrix of low qualifier floating-point numbers. 13 | /// There is no guarantee on the actual qualifier. 14 | /// 15 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 16 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 17 | typedef mat<2, 4, float, lowp> lowp_mat2x4; 18 | 19 | /// 2 columns of 4 components matrix of medium qualifier floating-point numbers. 20 | /// There is no guarantee on the actual qualifier. 21 | /// 22 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 23 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 24 | typedef mat<2, 4, float, mediump> mediump_mat2x4; 25 | 26 | /// 2 columns of 4 components matrix of high qualifier floating-point numbers. 27 | /// There is no guarantee on the actual qualifier. 28 | /// 29 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 30 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 31 | typedef mat<2, 4, float, highp> highp_mat2x4; 32 | 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /deps/glm/mat3x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat3x2.hpp 3 | 4 | #include "detail/setup.hpp" 5 | 6 | #pragma once 7 | 8 | #include "detail/type_mat3x2.hpp" 9 | 10 | namespace glm 11 | { 12 | /// 3 columns of 2 components matrix of low qualifier floating-point numbers. 13 | /// There is no guarantee on the actual qualifier. 14 | /// 15 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 16 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 17 | typedef mat<3, 2, float, lowp> lowp_mat3x2; 18 | 19 | /// 3 columns of 2 components matrix of medium qualifier floating-point numbers. 20 | /// There is no guarantee on the actual qualifier. 21 | /// 22 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 23 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 24 | typedef mat<3, 2, float, mediump> mediump_mat3x2; 25 | 26 | /// 3 columns of 2 components matrix of high qualifier floating-point numbers. 27 | /// There is no guarantee on the actual qualifier. 28 | /// 29 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 30 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 31 | typedef mat<3, 2, float, highp> highp_mat3x2; 32 | 33 | }//namespace 34 | -------------------------------------------------------------------------------- /deps/glm/mat3x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat3x3.hpp 3 | 4 | #include "detail/setup.hpp" 5 | 6 | #pragma once 7 | 8 | #include "detail/type_mat3x3.hpp" 9 | 10 | namespace glm 11 | { 12 | /// 3 columns of 3 components matrix of low qualifier floating-point numbers. 13 | /// There is no guarantee on the actual qualifier. 14 | /// 15 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 16 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 17 | typedef mat<3, 3, float, lowp> lowp_mat3; 18 | 19 | /// 3 columns of 3 components matrix of medium qualifier floating-point numbers. 20 | /// There is no guarantee on the actual qualifier. 21 | /// 22 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 23 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 24 | typedef mat<3, 3, float, mediump> mediump_mat3; 25 | 26 | /// 3 columns of 3 components matrix of high qualifier floating-point numbers. 27 | /// There is no guarantee on the actual qualifier. 28 | /// 29 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 30 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 31 | typedef mat<3, 3, float, highp> highp_mat3; 32 | 33 | /// 3 columns of 3 components matrix of low qualifier floating-point numbers. 34 | /// There is no guarantee on the actual qualifier. 35 | /// 36 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 37 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 38 | typedef mat<3, 3, float, lowp> lowp_mat3x3; 39 | 40 | /// 3 columns of 3 components matrix of medium qualifier floating-point numbers. 41 | /// There is no guarantee on the actual qualifier. 42 | /// 43 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 44 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 45 | typedef mat<3, 3, float, mediump> mediump_mat3x3; 46 | 47 | /// 3 columns of 3 components matrix of high qualifier floating-point numbers. 48 | /// There is no guarantee on the actual qualifier. 49 | /// 50 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 51 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 52 | typedef mat<3, 3, float, highp> highp_mat3x3; 53 | 54 | }//namespace glm 55 | -------------------------------------------------------------------------------- /deps/glm/mat3x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat3x4.hpp 3 | 4 | #include "detail/setup.hpp" 5 | 6 | #pragma once 7 | 8 | #include "detail/type_mat3x4.hpp" 9 | 10 | namespace glm 11 | { 12 | /// 3 columns of 4 components matrix of low qualifier floating-point numbers. 13 | /// There is no guarantee on the actual qualifier. 14 | /// 15 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 16 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 17 | typedef mat<3, 4, float, lowp> lowp_mat3x4; 18 | 19 | /// 3 columns of 4 components matrix of medium qualifier floating-point numbers. 20 | /// There is no guarantee on the actual qualifier. 21 | /// 22 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 23 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 24 | typedef mat<3, 4, float, mediump> mediump_mat3x4; 25 | 26 | /// 3 columns of 4 components matrix of high qualifier floating-point numbers. 27 | /// There is no guarantee on the actual qualifier. 28 | /// 29 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 30 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 31 | typedef mat<3, 4, float, highp> highp_mat3x4; 32 | 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /deps/glm/mat4x2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat4x2.hpp 3 | 4 | #include "detail/setup.hpp" 5 | 6 | #pragma once 7 | 8 | #include "detail/type_mat4x2.hpp" 9 | 10 | namespace glm 11 | { 12 | /// 4 columns of 2 components matrix of low qualifier floating-point numbers. 13 | /// There is no guarantee on the actual qualifier. 14 | /// 15 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 16 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 17 | typedef mat<4, 2, float, lowp> lowp_mat4x2; 18 | 19 | /// 4 columns of 2 components matrix of medium qualifier floating-point numbers. 20 | /// There is no guarantee on the actual qualifier. 21 | /// 22 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 23 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 24 | typedef mat<4, 2, float, mediump> mediump_mat4x2; 25 | 26 | /// 4 columns of 2 components matrix of high qualifier floating-point numbers. 27 | /// There is no guarantee on the actual qualifier. 28 | /// 29 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 30 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 31 | typedef mat<4, 2, float, highp> highp_mat4x2; 32 | 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /deps/glm/mat4x3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat4x3.hpp 3 | 4 | #include "detail/setup.hpp" 5 | 6 | #pragma once 7 | 8 | #include "detail/type_mat4x3.hpp" 9 | 10 | namespace glm 11 | { 12 | /// 4 columns of 3 components matrix of low qualifier floating-point numbers. 13 | /// There is no guarantee on the actual qualifier. 14 | /// 15 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 16 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 17 | typedef mat<4, 3, float, lowp> lowp_mat4x3; 18 | 19 | /// 4 columns of 3 components matrix of medium qualifier floating-point numbers. 20 | /// There is no guarantee on the actual qualifier. 21 | /// 22 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 23 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 24 | typedef mat<4, 3, float, mediump> mediump_mat4x3; 25 | 26 | /// 4 columns of 3 components matrix of high qualifier floating-point numbers. 27 | /// There is no guarantee on the actual qualifier. 28 | /// 29 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 30 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 31 | typedef mat<4, 3, float, highp> highp_mat4x3; 32 | 33 | }//namespace glm 34 | -------------------------------------------------------------------------------- /deps/glm/mat4x4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/mat4x4.hpp 3 | 4 | #include "detail/setup.hpp" 5 | 6 | #pragma once 7 | 8 | #include "detail/type_mat4x4.hpp" 9 | 10 | namespace glm 11 | { 12 | /// 4 columns of 4 components matrix of low qualifier floating-point numbers. 13 | /// There is no guarantee on the actual qualifier. 14 | /// 15 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 16 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 17 | typedef mat<4, 4, float, lowp> lowp_mat4; 18 | 19 | /// 4 columns of 4 components matrix of medium qualifier floating-point numbers. 20 | /// There is no guarantee on the actual qualifier. 21 | /// 22 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 23 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 24 | typedef mat<4, 4, float, mediump> mediump_mat4; 25 | 26 | /// 4 columns of 4 components matrix of high qualifier floating-point numbers. 27 | /// There is no guarantee on the actual qualifier. 28 | /// 29 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 30 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 31 | typedef mat<4, 4, float, highp> highp_mat4; 32 | 33 | /// 4 columns of 4 components matrix of low qualifier floating-point numbers. 34 | /// There is no guarantee on the actual qualifier. 35 | /// 36 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 37 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 38 | typedef mat<4, 4, float, lowp> lowp_mat4x4; 39 | 40 | /// 4 columns of 4 components matrix of medium qualifier floating-point numbers. 41 | /// There is no guarantee on the actual qualifier. 42 | /// 43 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 44 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 45 | typedef mat<4, 4, float, mediump> mediump_mat4x4; 46 | 47 | /// 4 columns of 4 components matrix of high qualifier floating-point numbers. 48 | /// There is no guarantee on the actual qualifier. 49 | /// 50 | /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices 51 | /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier 52 | typedef mat<4, 4, float, highp> highp_mat4x4; 53 | 54 | }//namespace glm 55 | -------------------------------------------------------------------------------- /deps/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_vec4 glm_vec1_sqrt_lowp(glm_vec4 x) 11 | { 12 | return _mm_mul_ss(_mm_rsqrt_ss(x), x); 13 | } 14 | 15 | GLM_FUNC_QUALIFIER glm_vec4 glm_vec4_sqrt_lowp(glm_vec4 x) 16 | { 17 | return _mm_mul_ps(_mm_rsqrt_ps(x), x); 18 | } 19 | 20 | #endif//GLM_ARCH & GLM_ARCH_SSE2_BIT 21 | -------------------------------------------------------------------------------- /deps/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 | -------------------------------------------------------------------------------- /deps/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 | -------------------------------------------------------------------------------- /deps/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 | -------------------------------------------------------------------------------- /deps/glm/vec2.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/vec2.hpp 3 | 4 | #include "detail/setup.hpp" 5 | 6 | #pragma once 7 | 8 | #include "detail/type_vec2.hpp" 9 | -------------------------------------------------------------------------------- /deps/glm/vec3.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/vec3.hpp 3 | 4 | #include "detail/setup.hpp" 5 | 6 | #pragma once 7 | 8 | #include "detail/type_vec3.hpp" 9 | -------------------------------------------------------------------------------- /deps/glm/vec4.hpp: -------------------------------------------------------------------------------- 1 | /// @ref core 2 | /// @file glm/vec4.hpp 3 | 4 | #include "detail/setup.hpp" 5 | 6 | #pragma once 7 | 8 | #include "detail/type_vec4.hpp" 9 | -------------------------------------------------------------------------------- /examples/dev/main.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/examples/dev/main.cpp -------------------------------------------------------------------------------- /examples/dev/main.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/examples/dev/main.h -------------------------------------------------------------------------------- /include/core/application.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/include/core/application.h -------------------------------------------------------------------------------- /include/core/types.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/include/core/types.h -------------------------------------------------------------------------------- /include/materials/material.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/include/materials/material.h -------------------------------------------------------------------------------- /include/materials/texture.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/include/materials/texture.h -------------------------------------------------------------------------------- /include/objects/aabb.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/include/objects/aabb.h -------------------------------------------------------------------------------- /include/objects/box.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/include/objects/box.h -------------------------------------------------------------------------------- /include/objects/bvh.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/include/objects/bvh.h -------------------------------------------------------------------------------- /include/objects/hitable.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/include/objects/hitable.h -------------------------------------------------------------------------------- /include/objects/objects.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/include/objects/objects.h -------------------------------------------------------------------------------- /include/objects/rect.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/include/objects/rect.h -------------------------------------------------------------------------------- /include/objects/sphere.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/include/objects/sphere.h -------------------------------------------------------------------------------- /include/objects/volume.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/include/objects/volume.h -------------------------------------------------------------------------------- /include/renderer/camera.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/include/renderer/camera.h -------------------------------------------------------------------------------- /include/renderer/ray.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/include/renderer/ray.h -------------------------------------------------------------------------------- /include/renderer/renderer.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/include/renderer/renderer.h -------------------------------------------------------------------------------- /include/renderer/scene.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/include/renderer/scene.h -------------------------------------------------------------------------------- /include/utils/bitmap.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/include/utils/bitmap.h -------------------------------------------------------------------------------- /include/utils/perlin.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/include/utils/perlin.h -------------------------------------------------------------------------------- /project/vs2017/dev.vcxproj.filters: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | {84D830B1-70A5-8BBC-99BE-796485EAC04A} 6 | 7 | 8 | {3FA46517-2B07-F5BB-D48C-2D72C0CEC03E} 9 | 10 | 11 | 12 | 13 | examples\dev 14 | 15 | 16 | 17 | 18 | examples\dev 19 | 20 | 21 | 22 | -------------------------------------------------------------------------------- /project/vs2017/dev.vcxproj.user: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | WindowsLocalDebugger 5 | ..\..\examples\dev 6 | 7 | 8 | 9 | WindowsLocalDebugger 10 | ..\..\examples\dev 11 | 12 | 13 | 14 | WindowsLocalDebugger 15 | ..\..\examples\dev 16 | 17 | 18 | 19 | WindowsLocalDebugger 20 | ..\..\examples\dev 21 | 22 | 23 | 24 | -------------------------------------------------------------------------------- /project/vs2017/vxt-Raytracing.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio 15 4 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dev", "dev.vcxproj", "{C469880B-3073-887C-B9EE-9E7C25F7937C}" 5 | ProjectSection(ProjectDependencies) = postProject 6 | {C7B8880B-33C2-887C-BC3D-9F7C2846947C} = {C7B8880B-33C2-887C-BC3D-9F7C2846947C} 7 | EndProjectSection 8 | EndProject 9 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vxt", "vxt.vcxproj", "{C7B8880B-33C2-887C-BC3D-9F7C2846947C}" 10 | EndProject 11 | Global 12 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 13 | Debug|Win32 = Debug|Win32 14 | Debug|x64 = Debug|x64 15 | Release|Win32 = Release|Win32 16 | Release|x64 = Release|x64 17 | EndGlobalSection 18 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 19 | {C469880B-3073-887C-B9EE-9E7C25F7937C}.Debug|Win32.ActiveCfg = Debug|Win32 20 | {C469880B-3073-887C-B9EE-9E7C25F7937C}.Debug|Win32.Build.0 = Debug|Win32 21 | {C469880B-3073-887C-B9EE-9E7C25F7937C}.Debug|x64.ActiveCfg = Debug|x64 22 | {C469880B-3073-887C-B9EE-9E7C25F7937C}.Debug|x64.Build.0 = Debug|x64 23 | {C469880B-3073-887C-B9EE-9E7C25F7937C}.Release|Win32.ActiveCfg = Release|Win32 24 | {C469880B-3073-887C-B9EE-9E7C25F7937C}.Release|Win32.Build.0 = Release|Win32 25 | {C469880B-3073-887C-B9EE-9E7C25F7937C}.Release|x64.ActiveCfg = Release|x64 26 | {C469880B-3073-887C-B9EE-9E7C25F7937C}.Release|x64.Build.0 = Release|x64 27 | {C7B8880B-33C2-887C-BC3D-9F7C2846947C}.Debug|Win32.ActiveCfg = Debug|Win32 28 | {C7B8880B-33C2-887C-BC3D-9F7C2846947C}.Debug|Win32.Build.0 = Debug|Win32 29 | {C7B8880B-33C2-887C-BC3D-9F7C2846947C}.Debug|x64.ActiveCfg = Debug|x64 30 | {C7B8880B-33C2-887C-BC3D-9F7C2846947C}.Debug|x64.Build.0 = Debug|x64 31 | {C7B8880B-33C2-887C-BC3D-9F7C2846947C}.Release|Win32.ActiveCfg = Release|Win32 32 | {C7B8880B-33C2-887C-BC3D-9F7C2846947C}.Release|Win32.Build.0 = Release|Win32 33 | {C7B8880B-33C2-887C-BC3D-9F7C2846947C}.Release|x64.ActiveCfg = Release|x64 34 | {C7B8880B-33C2-887C-BC3D-9F7C2846947C}.Release|x64.Build.0 = Release|x64 35 | EndGlobalSection 36 | GlobalSection(SolutionProperties) = preSolution 37 | HideSolutionNode = FALSE 38 | EndGlobalSection 39 | GlobalSection(NestedProjects) = preSolution 40 | EndGlobalSection 41 | EndGlobal 42 | -------------------------------------------------------------------------------- /project/vs2017/vxt.vcxproj.user: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | WindowsLocalDebugger 5 | 6 | 7 | 8 | WindowsLocalDebugger 9 | 10 | 11 | 12 | WindowsLocalDebugger 13 | 14 | 15 | 16 | WindowsLocalDebugger 17 | 18 | 19 | 20 | -------------------------------------------------------------------------------- /src/core/application.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/src/core/application.cpp -------------------------------------------------------------------------------- /src/materials/material.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/src/materials/material.cpp -------------------------------------------------------------------------------- /src/materials/texture.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/src/materials/texture.cpp -------------------------------------------------------------------------------- /src/objects/aabb.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/src/objects/aabb.cpp -------------------------------------------------------------------------------- /src/objects/box.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/src/objects/box.cpp -------------------------------------------------------------------------------- /src/objects/bvh.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/src/objects/bvh.cpp -------------------------------------------------------------------------------- /src/objects/hitable.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/src/objects/hitable.cpp -------------------------------------------------------------------------------- /src/objects/rect.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/src/objects/rect.cpp -------------------------------------------------------------------------------- /src/objects/sphere.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/src/objects/sphere.cpp -------------------------------------------------------------------------------- /src/objects/volume.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/src/objects/volume.cpp -------------------------------------------------------------------------------- /src/renderer/camera.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/src/renderer/camera.cpp -------------------------------------------------------------------------------- /src/renderer/renderer.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/src/renderer/renderer.cpp -------------------------------------------------------------------------------- /src/renderer/scene.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/src/renderer/scene.cpp -------------------------------------------------------------------------------- /src/utils/bitmap.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/src/utils/bitmap.cpp -------------------------------------------------------------------------------- /src/utils/perlin.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/src/utils/perlin.cpp -------------------------------------------------------------------------------- /tools/genie.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/avilapa/vxt/b4bd9246fdf6fecc0e076943871558a9764dfbb2/tools/genie.exe --------------------------------------------------------------------------------