From 6f67371bb1b46579ae837d0e0c61ac1b291be743 Mon Sep 17 00:00:00 2001 From: LaG1924 <12997935+LaG1924@users.noreply.github.com> Date: Sat, 13 Jan 2018 07:51:33 +0500 Subject: Directory renamed --- external/include/glm/gtx/associated_min_max.hpp | 202 +++++ external/include/glm/gtx/associated_min_max.inl | 355 ++++++++ external/include/glm/gtx/bit.hpp | 95 ++ external/include/glm/gtx/bit.inl | 93 ++ external/include/glm/gtx/closest_point.hpp | 45 + external/include/glm/gtx/closest_point.inl | 46 + external/include/glm/gtx/color_space.hpp | 68 ++ external/include/glm/gtx/color_space.inl | 141 +++ external/include/glm/gtx/color_space_YCoCg.hpp | 56 ++ external/include/glm/gtx/color_space_YCoCg.inl | 108 +++ external/include/glm/gtx/common.hpp | 53 ++ external/include/glm/gtx/common.inl | 112 +++ external/include/glm/gtx/compatibility.hpp | 130 +++ external/include/glm/gtx/compatibility.inl | 65 ++ external/include/glm/gtx/component_wise.hpp | 65 ++ external/include/glm/gtx/component_wise.inl | 128 +++ external/include/glm/gtx/dual_quaternion.hpp | 266 ++++++ external/include/glm/gtx/dual_quaternion.inl | 351 ++++++++ external/include/glm/gtx/euler_angles.hpp | 143 +++ external/include/glm/gtx/euler_angles.inl | 312 +++++++ external/include/glm/gtx/extend.hpp | 38 + external/include/glm/gtx/extend.inl | 49 ++ external/include/glm/gtx/extended_min_max.hpp | 133 +++ external/include/glm/gtx/extended_min_max.inl | 140 +++ external/include/glm/gtx/fast_exponential.hpp | 91 ++ external/include/glm/gtx/fast_exponential.inl | 137 +++ external/include/glm/gtx/fast_square_root.hpp | 88 ++ external/include/glm/gtx/fast_square_root.inl | 81 ++ external/include/glm/gtx/fast_trigonometry.hpp | 75 ++ external/include/glm/gtx/fast_trigonometry.inl | 143 +++ external/include/glm/gtx/float_notmalize.inl | 14 + external/include/glm/gtx/gradient_paint.hpp | 48 + external/include/glm/gtx/gradient_paint.inl | 37 + .../include/glm/gtx/handed_coordinate_space.hpp | 46 + .../include/glm/gtx/handed_coordinate_space.inl | 27 + external/include/glm/gtx/hash.hpp | 134 +++ external/include/glm/gtx/hash.inl | 185 ++++ external/include/glm/gtx/integer.hpp | 72 ++ external/include/glm/gtx/integer.inl | 182 ++++ external/include/glm/gtx/intersect.hpp | 87 ++ external/include/glm/gtx/intersect.inl | 170 ++++ external/include/glm/gtx/io.hpp | 197 +++++ external/include/glm/gtx/io.inl | 441 ++++++++++ external/include/glm/gtx/log_base.hpp | 44 + external/include/glm/gtx/log_base.inl | 18 + external/include/glm/gtx/matrix_cross_product.hpp | 43 + external/include/glm/gtx/matrix_cross_product.inl | 38 + external/include/glm/gtx/matrix_decompose.hpp | 42 + external/include/glm/gtx/matrix_decompose.inl | 194 +++++ external/include/glm/gtx/matrix_interpolation.hpp | 61 ++ external/include/glm/gtx/matrix_interpolation.inl | 134 +++ external/include/glm/gtx/matrix_major_storage.hpp | 115 +++ external/include/glm/gtx/matrix_major_storage.inl | 167 ++++ external/include/glm/gtx/matrix_operation.hpp | 84 ++ external/include/glm/gtx/matrix_operation.inl | 118 +++ external/include/glm/gtx/matrix_query.hpp | 73 ++ external/include/glm/gtx/matrix_query.inl | 114 +++ external/include/glm/gtx/matrix_transform_2d.hpp | 78 ++ external/include/glm/gtx/matrix_transform_2d.inl | 69 ++ external/include/glm/gtx/mixed_product.hpp | 37 + external/include/glm/gtx/mixed_product.inl | 16 + external/include/glm/gtx/norm.hpp | 86 ++ external/include/glm/gtx/norm.inl | 106 +++ external/include/glm/gtx/normal.hpp | 39 + external/include/glm/gtx/normal.inl | 16 + external/include/glm/gtx/normalize_dot.hpp | 45 + external/include/glm/gtx/normalize_dot.inl | 17 + external/include/glm/gtx/number_precision.hpp | 57 ++ external/include/glm/gtx/number_precision.inl | 7 + external/include/glm/gtx/optimum_pow.hpp | 50 ++ external/include/glm/gtx/optimum_pow.inl | 23 + external/include/glm/gtx/orthonormalize.hpp | 45 + external/include/glm/gtx/orthonormalize.inl | 30 + external/include/glm/gtx/perpendicular.hpp | 39 + external/include/glm/gtx/perpendicular.inl | 15 + external/include/glm/gtx/polar_coordinates.hpp | 44 + external/include/glm/gtx/polar_coordinates.inl | 37 + external/include/glm/gtx/projection.hpp | 36 + external/include/glm/gtx/projection.inl | 11 + external/include/glm/gtx/quaternion.hpp | 185 ++++ external/include/glm/gtx/quaternion.inl | 212 +++++ external/include/glm/gtx/range.hpp | 85 ++ external/include/glm/gtx/raw_data.hpp | 47 + external/include/glm/gtx/raw_data.inl | 2 + .../include/glm/gtx/rotate_normalized_axis.hpp | 64 ++ .../include/glm/gtx/rotate_normalized_axis.inl | 59 ++ external/include/glm/gtx/rotate_vector.hpp | 117 +++ external/include/glm/gtx/rotate_vector.inl | 188 ++++ external/include/glm/gtx/scalar_multiplication.hpp | 69 ++ external/include/glm/gtx/scalar_relational.hpp | 32 + external/include/glm/gtx/scalar_relational.inl | 89 ++ external/include/glm/gtx/simd_mat4.hpp | 182 ++++ external/include/glm/gtx/simd_mat4.inl | 577 ++++++++++++ external/include/glm/gtx/simd_quat.hpp | 307 +++++++ external/include/glm/gtx/simd_quat.inl | 620 +++++++++++++ external/include/glm/gtx/simd_vec4.hpp | 546 ++++++++++++ external/include/glm/gtx/simd_vec4.inl | 721 +++++++++++++++ external/include/glm/gtx/spline.hpp | 61 ++ external/include/glm/gtx/spline.inl | 63 ++ external/include/glm/gtx/std_based_type.hpp | 63 ++ external/include/glm/gtx/std_based_type.inl | 7 + external/include/glm/gtx/string_cast.hpp | 47 + external/include/glm/gtx/string_cast.inl | 458 ++++++++++ external/include/glm/gtx/transform.hpp | 56 ++ external/include/glm/gtx/transform.inl | 24 + external/include/glm/gtx/transform2.hpp | 107 +++ external/include/glm/gtx/transform2.inl | 126 +++ external/include/glm/gtx/type_aligned.hpp | 966 +++++++++++++++++++++ external/include/glm/gtx/type_aligned.inl | 7 + external/include/glm/gtx/type_trait.hpp | 252 ++++++ external/include/glm/gtx/type_trait.inl | 0 external/include/glm/gtx/vector_angle.hpp | 60 ++ external/include/glm/gtx/vector_angle.inl | 58 ++ external/include/glm/gtx/vector_query.hpp | 62 ++ external/include/glm/gtx/vector_query.inl | 193 ++++ external/include/glm/gtx/wrap.hpp | 51 ++ external/include/glm/gtx/wrap.inl | 58 ++ 117 files changed, 14418 insertions(+) create mode 100644 external/include/glm/gtx/associated_min_max.hpp create mode 100644 external/include/glm/gtx/associated_min_max.inl create mode 100644 external/include/glm/gtx/bit.hpp create mode 100644 external/include/glm/gtx/bit.inl create mode 100644 external/include/glm/gtx/closest_point.hpp create mode 100644 external/include/glm/gtx/closest_point.inl create mode 100644 external/include/glm/gtx/color_space.hpp create mode 100644 external/include/glm/gtx/color_space.inl create mode 100644 external/include/glm/gtx/color_space_YCoCg.hpp create mode 100644 external/include/glm/gtx/color_space_YCoCg.inl create mode 100644 external/include/glm/gtx/common.hpp create mode 100644 external/include/glm/gtx/common.inl create mode 100644 external/include/glm/gtx/compatibility.hpp create mode 100644 external/include/glm/gtx/compatibility.inl create mode 100644 external/include/glm/gtx/component_wise.hpp create mode 100644 external/include/glm/gtx/component_wise.inl create mode 100644 external/include/glm/gtx/dual_quaternion.hpp create mode 100644 external/include/glm/gtx/dual_quaternion.inl create mode 100644 external/include/glm/gtx/euler_angles.hpp create mode 100644 external/include/glm/gtx/euler_angles.inl create mode 100644 external/include/glm/gtx/extend.hpp create mode 100644 external/include/glm/gtx/extend.inl create mode 100644 external/include/glm/gtx/extended_min_max.hpp create mode 100644 external/include/glm/gtx/extended_min_max.inl create mode 100644 external/include/glm/gtx/fast_exponential.hpp create mode 100644 external/include/glm/gtx/fast_exponential.inl create mode 100644 external/include/glm/gtx/fast_square_root.hpp create mode 100644 external/include/glm/gtx/fast_square_root.inl create mode 100644 external/include/glm/gtx/fast_trigonometry.hpp create mode 100644 external/include/glm/gtx/fast_trigonometry.inl create mode 100644 external/include/glm/gtx/float_notmalize.inl create mode 100644 external/include/glm/gtx/gradient_paint.hpp create mode 100644 external/include/glm/gtx/gradient_paint.inl create mode 100644 external/include/glm/gtx/handed_coordinate_space.hpp create mode 100644 external/include/glm/gtx/handed_coordinate_space.inl create mode 100644 external/include/glm/gtx/hash.hpp create mode 100644 external/include/glm/gtx/hash.inl create mode 100644 external/include/glm/gtx/integer.hpp create mode 100644 external/include/glm/gtx/integer.inl create mode 100644 external/include/glm/gtx/intersect.hpp create mode 100644 external/include/glm/gtx/intersect.inl create mode 100644 external/include/glm/gtx/io.hpp create mode 100644 external/include/glm/gtx/io.inl create mode 100644 external/include/glm/gtx/log_base.hpp create mode 100644 external/include/glm/gtx/log_base.inl create mode 100644 external/include/glm/gtx/matrix_cross_product.hpp create mode 100644 external/include/glm/gtx/matrix_cross_product.inl create mode 100644 external/include/glm/gtx/matrix_decompose.hpp create mode 100644 external/include/glm/gtx/matrix_decompose.inl create mode 100644 external/include/glm/gtx/matrix_interpolation.hpp create mode 100644 external/include/glm/gtx/matrix_interpolation.inl create mode 100644 external/include/glm/gtx/matrix_major_storage.hpp create mode 100644 external/include/glm/gtx/matrix_major_storage.inl create mode 100644 external/include/glm/gtx/matrix_operation.hpp create mode 100644 external/include/glm/gtx/matrix_operation.inl create mode 100644 external/include/glm/gtx/matrix_query.hpp create mode 100644 external/include/glm/gtx/matrix_query.inl create mode 100644 external/include/glm/gtx/matrix_transform_2d.hpp create mode 100644 external/include/glm/gtx/matrix_transform_2d.inl create mode 100644 external/include/glm/gtx/mixed_product.hpp create mode 100644 external/include/glm/gtx/mixed_product.inl create mode 100644 external/include/glm/gtx/norm.hpp create mode 100644 external/include/glm/gtx/norm.inl create mode 100644 external/include/glm/gtx/normal.hpp create mode 100644 external/include/glm/gtx/normal.inl create mode 100644 external/include/glm/gtx/normalize_dot.hpp create mode 100644 external/include/glm/gtx/normalize_dot.inl create mode 100644 external/include/glm/gtx/number_precision.hpp create mode 100644 external/include/glm/gtx/number_precision.inl create mode 100644 external/include/glm/gtx/optimum_pow.hpp create mode 100644 external/include/glm/gtx/optimum_pow.inl create mode 100644 external/include/glm/gtx/orthonormalize.hpp create mode 100644 external/include/glm/gtx/orthonormalize.inl create mode 100644 external/include/glm/gtx/perpendicular.hpp create mode 100644 external/include/glm/gtx/perpendicular.inl create mode 100644 external/include/glm/gtx/polar_coordinates.hpp create mode 100644 external/include/glm/gtx/polar_coordinates.inl create mode 100644 external/include/glm/gtx/projection.hpp create mode 100644 external/include/glm/gtx/projection.inl create mode 100644 external/include/glm/gtx/quaternion.hpp create mode 100644 external/include/glm/gtx/quaternion.inl create mode 100644 external/include/glm/gtx/range.hpp create mode 100644 external/include/glm/gtx/raw_data.hpp create mode 100644 external/include/glm/gtx/raw_data.inl create mode 100644 external/include/glm/gtx/rotate_normalized_axis.hpp create mode 100644 external/include/glm/gtx/rotate_normalized_axis.inl create mode 100644 external/include/glm/gtx/rotate_vector.hpp create mode 100644 external/include/glm/gtx/rotate_vector.inl create mode 100644 external/include/glm/gtx/scalar_multiplication.hpp create mode 100644 external/include/glm/gtx/scalar_relational.hpp create mode 100644 external/include/glm/gtx/scalar_relational.inl create mode 100644 external/include/glm/gtx/simd_mat4.hpp create mode 100644 external/include/glm/gtx/simd_mat4.inl create mode 100644 external/include/glm/gtx/simd_quat.hpp create mode 100644 external/include/glm/gtx/simd_quat.inl create mode 100644 external/include/glm/gtx/simd_vec4.hpp create mode 100644 external/include/glm/gtx/simd_vec4.inl create mode 100644 external/include/glm/gtx/spline.hpp create mode 100644 external/include/glm/gtx/spline.inl create mode 100644 external/include/glm/gtx/std_based_type.hpp create mode 100644 external/include/glm/gtx/std_based_type.inl create mode 100644 external/include/glm/gtx/string_cast.hpp create mode 100644 external/include/glm/gtx/string_cast.inl create mode 100644 external/include/glm/gtx/transform.hpp create mode 100644 external/include/glm/gtx/transform.inl create mode 100644 external/include/glm/gtx/transform2.hpp create mode 100644 external/include/glm/gtx/transform2.inl create mode 100644 external/include/glm/gtx/type_aligned.hpp create mode 100644 external/include/glm/gtx/type_aligned.inl create mode 100644 external/include/glm/gtx/type_trait.hpp create mode 100644 external/include/glm/gtx/type_trait.inl create mode 100644 external/include/glm/gtx/vector_angle.hpp create mode 100644 external/include/glm/gtx/vector_angle.inl create mode 100644 external/include/glm/gtx/vector_query.hpp create mode 100644 external/include/glm/gtx/vector_query.inl create mode 100644 external/include/glm/gtx/wrap.hpp create mode 100644 external/include/glm/gtx/wrap.inl (limited to 'external/include/glm/gtx') diff --git a/external/include/glm/gtx/associated_min_max.hpp b/external/include/glm/gtx/associated_min_max.hpp new file mode 100644 index 0000000..eb9d721 --- /dev/null +++ b/external/include/glm/gtx/associated_min_max.hpp @@ -0,0 +1,202 @@ +/// @ref gtx_associated_min_max +/// @file glm/gtx/associated_min_max.hpp +/// +/// @see core (dependence) +/// @see gtx_extented_min_max (dependence) +/// +/// @defgroup gtx_associated_min_max GLM_GTX_associated_min_max +/// @ingroup gtx +/// +/// @brief Min and max functions that return associated values not the compared onces. +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../glm.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_associated_min_max extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_associated_min_max + /// @{ + + /// Minimum comparison between 2 variables and returns 2 associated variable values + /// @see gtx_associated_min_max + template + GLM_FUNC_DECL U associatedMin(T x, U a, T y, U b); + + /// Minimum comparison between 2 variables and returns 2 associated variable values + /// @see gtx_associated_min_max + template class vecType> + GLM_FUNC_DECL tvec2 associatedMin( + vecType const & x, vecType const & a, + vecType const & y, vecType const & b); + + /// Minimum comparison between 2 variables and returns 2 associated variable values + /// @see gtx_associated_min_max + template class vecType> + GLM_FUNC_DECL vecType associatedMin( + T x, const vecType& a, + T y, const vecType& b); + + /// Minimum comparison between 2 variables and returns 2 associated variable values + /// @see gtx_associated_min_max + template class vecType> + GLM_FUNC_DECL vecType associatedMin( + vecType const & x, U a, + vecType const & y, U b); + + /// Minimum comparison between 3 variables and returns 3 associated variable values + /// @see gtx_associated_min_max + template + GLM_FUNC_DECL U associatedMin( + T x, U a, + T y, U b, + T z, U c); + + /// Minimum comparison between 3 variables and returns 3 associated variable values + /// @see gtx_associated_min_max + template class vecType> + GLM_FUNC_DECL vecType associatedMin( + vecType const & x, vecType const & a, + vecType const & y, vecType const & b, + vecType const & z, vecType const & c); + + /// Minimum comparison between 4 variables and returns 4 associated variable values + /// @see gtx_associated_min_max + template + GLM_FUNC_DECL U associatedMin( + T x, U a, + T y, U b, + T z, U c, + T w, U d); + + /// Minimum comparison between 4 variables and returns 4 associated variable values + /// @see gtx_associated_min_max + template class vecType> + GLM_FUNC_DECL vecType associatedMin( + vecType const & x, vecType const & a, + vecType const & y, vecType const & b, + vecType const & z, vecType const & c, + vecType const & w, vecType const & d); + + /// Minimum comparison between 4 variables and returns 4 associated variable values + /// @see gtx_associated_min_max + template class vecType> + GLM_FUNC_DECL vecType associatedMin( + T x, vecType const & a, + T y, vecType const & b, + T z, vecType const & c, + T w, vecType const & d); + + /// Minimum comparison between 4 variables and returns 4 associated variable values + /// @see gtx_associated_min_max + template class vecType> + GLM_FUNC_DECL vecType associatedMin( + vecType const & x, U a, + vecType const & y, U b, + vecType const & z, U c, + vecType const & w, U d); + + /// Maximum comparison between 2 variables and returns 2 associated variable values + /// @see gtx_associated_min_max + template + GLM_FUNC_DECL U associatedMax(T x, U a, T y, U b); + + /// Maximum comparison between 2 variables and returns 2 associated variable values + /// @see gtx_associated_min_max + template class vecType> + GLM_FUNC_DECL tvec2 associatedMax( + vecType const & x, vecType const & a, + vecType const & y, vecType const & b); + + /// Maximum comparison between 2 variables and returns 2 associated variable values + /// @see gtx_associated_min_max + template class vecType> + GLM_FUNC_DECL vecType associatedMax( + T x, vecType const & a, + T y, vecType const & b); + + /// Maximum comparison between 2 variables and returns 2 associated variable values + /// @see gtx_associated_min_max + template class vecType> + GLM_FUNC_DECL vecType associatedMax( + vecType const & x, U a, + vecType const & y, U b); + + /// Maximum comparison between 3 variables and returns 3 associated variable values + /// @see gtx_associated_min_max + template + GLM_FUNC_DECL U associatedMax( + T x, U a, + T y, U b, + T z, U c); + + /// Maximum comparison between 3 variables and returns 3 associated variable values + /// @see gtx_associated_min_max + template class vecType> + GLM_FUNC_DECL vecType associatedMax( + vecType const & x, vecType const & a, + vecType const & y, vecType const & b, + vecType const & z, vecType const & c); + + /// Maximum comparison between 3 variables and returns 3 associated variable values + /// @see gtx_associated_min_max + template class vecType> + GLM_FUNC_DECL vecType associatedMax( + T x, vecType const & a, + T y, vecType const & b, + T z, vecType const & c); + + /// Maximum comparison between 3 variables and returns 3 associated variable values + /// @see gtx_associated_min_max + template class vecType> + GLM_FUNC_DECL vecType associatedMax( + vecType const & x, U a, + vecType const & y, U b, + vecType const & z, U c); + + /// Maximum comparison between 4 variables and returns 4 associated variable values + /// @see gtx_associated_min_max + template + GLM_FUNC_DECL U associatedMax( + T x, U a, + T y, U b, + T z, U c, + T w, U d); + + /// Maximum comparison between 4 variables and returns 4 associated variable values + /// @see gtx_associated_min_max + template class vecType> + GLM_FUNC_DECL vecType associatedMax( + vecType const & x, vecType const & a, + vecType const & y, vecType const & b, + vecType const & z, vecType const & c, + vecType const & w, vecType const & d); + + /// Maximum comparison between 4 variables and returns 4 associated variable values + /// @see gtx_associated_min_max + template class vecType> + GLM_FUNC_DECL vecType associatedMax( + T x, vecType const & a, + T y, vecType const & b, + T z, vecType const & c, + T w, vecType const & d); + + /// Maximum comparison between 4 variables and returns 4 associated variable values + /// @see gtx_associated_min_max + template class vecType> + GLM_FUNC_DECL vecType associatedMax( + vecType const & x, U a, + vecType const & y, U b, + vecType const & z, U c, + vecType const & w, U d); + + /// @} +} //namespace glm + +#include "associated_min_max.inl" diff --git a/external/include/glm/gtx/associated_min_max.inl b/external/include/glm/gtx/associated_min_max.inl new file mode 100644 index 0000000..6a57d48 --- /dev/null +++ b/external/include/glm/gtx/associated_min_max.inl @@ -0,0 +1,355 @@ +/// @ref gtx_associated_min_max +/// @file glm/gtx/associated_min_max.inl + +namespace glm{ + +// Min comparison between 2 variables +template +GLM_FUNC_QUALIFIER U associatedMin(T x, U a, T y, U b) +{ + return x < y ? a : b; +} + +template class vecType> +GLM_FUNC_QUALIFIER tvec2 associatedMin +( + vecType const & x, vecType const & a, + vecType const & y, vecType const & b +) +{ + vecType Result(uninitialize); + for(length_t i = 0, n = Result.length(); i < n; ++i) + Result[i] = x[i] < y[i] ? a[i] : b[i]; + return Result; +} + +template class vecType> +GLM_FUNC_QUALIFIER vecType associatedMin +( + T x, const vecType& a, + T y, const vecType& b +) +{ + vecType Result(uninitialize); + for(length_t i = 0, n = Result.length(); i < n; ++i) + Result[i] = x < y ? a[i] : b[i]; + return Result; +} + +template class vecType> +GLM_FUNC_QUALIFIER vecType associatedMin +( + vecType const & x, U a, + vecType const & y, U b +) +{ + vecType Result(uninitialize); + for(length_t i = 0, n = Result.length(); i < n; ++i) + Result[i] = x[i] < y[i] ? a : b; + return Result; +} + +// Min comparison between 3 variables +template +GLM_FUNC_QUALIFIER U associatedMin +( + T x, U a, + T y, U b, + T z, U c +) +{ + U Result = x < y ? (x < z ? a : c) : (y < z ? b : c); + return Result; +} + +template class vecType> +GLM_FUNC_QUALIFIER vecType associatedMin +( + vecType const & x, vecType const & a, + vecType const & y, vecType const & b, + vecType const & z, vecType const & c +) +{ + vecType Result(uninitialize); + for(length_t i = 0, n = Result.length(); i < n; ++i) + Result[i] = x[i] < y[i] ? (x[i] < z[i] ? a[i] : c[i]) : (y[i] < z[i] ? b[i] : c[i]); + return Result; +} + +// Min comparison between 4 variables +template +GLM_FUNC_QUALIFIER U associatedMin +( + T x, U a, + T y, U b, + T z, U c, + T w, U d +) +{ + T Test1 = min(x, y); + T Test2 = min(z, w);; + U Result1 = x < y ? a : b; + U Result2 = z < w ? c : d; + U Result = Test1 < Test2 ? Result1 : Result2; + return Result; +} + +// Min comparison between 4 variables +template class vecType> +GLM_FUNC_QUALIFIER vecType associatedMin +( + vecType const & x, vecType const & a, + vecType const & y, vecType const & b, + vecType const & z, vecType const & c, + vecType const & w, vecType const & d +) +{ + vecType Result(uninitialize); + for(length_t i = 0, n = Result.length(); i < n; ++i) + { + T Test1 = min(x[i], y[i]); + T Test2 = min(z[i], w[i]); + U Result1 = x[i] < y[i] ? a[i] : b[i]; + U Result2 = z[i] < w[i] ? c[i] : d[i]; + Result[i] = Test1 < Test2 ? Result1 : Result2; + } + return Result; +} + +// Min comparison between 4 variables +template class vecType> +GLM_FUNC_QUALIFIER vecType associatedMin +( + T x, vecType const & a, + T y, vecType const & b, + T z, vecType const & c, + T w, vecType const & d +) +{ + T Test1 = min(x, y); + T Test2 = min(z, w); + + vecType Result(uninitialize); + for(length_t i = 0, n = Result.length(); i < n; ++i) + { + U Result1 = x < y ? a[i] : b[i]; + U Result2 = z < w ? c[i] : d[i]; + Result[i] = Test1 < Test2 ? Result1 : Result2; + } + return Result; +} + +// Min comparison between 4 variables +template class vecType> +GLM_FUNC_QUALIFIER vecType associatedMin +( + vecType const & x, U a, + vecType const & y, U b, + vecType const & z, U c, + vecType const & w, U d +) +{ + vecType Result(uninitialize); + for(length_t i = 0, n = Result.length(); i < n; ++i) + { + T Test1 = min(x[i], y[i]); + T Test2 = min(z[i], w[i]);; + U Result1 = x[i] < y[i] ? a : b; + U Result2 = z[i] < w[i] ? c : d; + Result[i] = Test1 < Test2 ? Result1 : Result2; + } + return Result; +} + +// Max comparison between 2 variables +template +GLM_FUNC_QUALIFIER U associatedMax(T x, U a, T y, U b) +{ + return x > y ? a : b; +} + +// Max comparison between 2 variables +template class vecType> +GLM_FUNC_QUALIFIER tvec2 associatedMax +( + vecType const & x, vecType const & a, + vecType const & y, vecType const & b +) +{ + vecType Result(uninitialize); + for(length_t i = 0, n = Result.length(); i < n; ++i) + Result[i] = x[i] > y[i] ? a[i] : b[i]; + return Result; +} + +// Max comparison between 2 variables +template class vecType> +GLM_FUNC_QUALIFIER vecType associatedMax +( + T x, vecType const & a, + T y, vecType const & b +) +{ + vecType Result(uninitialize); + for(length_t i = 0, n = Result.length(); i < n; ++i) + Result[i] = x > y ? a[i] : b[i]; + return Result; +} + +// Max comparison between 2 variables +template class vecType> +GLM_FUNC_QUALIFIER vecType associatedMax +( + vecType const & x, U a, + vecType const & y, U b +) +{ + vecType Result(uninitialize); + for(length_t i = 0, n = Result.length(); i < n; ++i) + Result[i] = x[i] > y[i] ? a : b; + return Result; +} + +// Max comparison between 3 variables +template +GLM_FUNC_QUALIFIER U associatedMax +( + T x, U a, + T y, U b, + T z, U c +) +{ + U Result = x > y ? (x > z ? a : c) : (y > z ? b : c); + return Result; +} + +// Max comparison between 3 variables +template class vecType> +GLM_FUNC_QUALIFIER vecType associatedMax +( + vecType const & x, vecType const & a, + vecType const & y, vecType const & b, + vecType const & z, vecType const & c +) +{ + vecType Result(uninitialize); + for(length_t i = 0, n = Result.length(); i < n; ++i) + Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a[i] : c[i]) : (y[i] > z[i] ? b[i] : c[i]); + return Result; +} + +// Max comparison between 3 variables +template class vecType> +GLM_FUNC_QUALIFIER vecType associatedMax +( + T x, vecType const & a, + T y, vecType const & b, + T z, vecType const & c +) +{ + vecType Result(uninitialize); + for(length_t i = 0, n = Result.length(); i < n; ++i) + Result[i] = x > y ? (x > z ? a[i] : c[i]) : (y > z ? b[i] : c[i]); + return Result; +} + +// Max comparison between 3 variables +template class vecType> +GLM_FUNC_QUALIFIER vecType associatedMax +( + vecType const & x, U a, + vecType const & y, U b, + vecType const & z, U c +) +{ + vecType Result(uninitialize); + for(length_t i = 0, n = Result.length(); i < n; ++i) + Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a : c) : (y[i] > z[i] ? b : c); + return Result; +} + +// Max comparison between 4 variables +template +GLM_FUNC_QUALIFIER U associatedMax +( + T x, U a, + T y, U b, + T z, U c, + T w, U d +) +{ + T Test1 = max(x, y); + T Test2 = max(z, w);; + U Result1 = x > y ? a : b; + U Result2 = z > w ? c : d; + U Result = Test1 > Test2 ? Result1 : Result2; + return Result; +} + +// Max comparison between 4 variables +template class vecType> +GLM_FUNC_QUALIFIER vecType associatedMax +( + vecType const & x, vecType const & a, + vecType const & y, vecType const & b, + vecType const & z, vecType const & c, + vecType const & w, vecType const & d +) +{ + vecType Result(uninitialize); + for(length_t i = 0, n = Result.length(); i < n; ++i) + { + T Test1 = max(x[i], y[i]); + T Test2 = max(z[i], w[i]); + U Result1 = x[i] > y[i] ? a[i] : b[i]; + U Result2 = z[i] > w[i] ? c[i] : d[i]; + Result[i] = Test1 > Test2 ? Result1 : Result2; + } + return Result; +} + +// Max comparison between 4 variables +template class vecType> +GLM_FUNC_QUALIFIER vecType associatedMax +( + T x, vecType const & a, + T y, vecType const & b, + T z, vecType const & c, + T w, vecType const & d +) +{ + T Test1 = max(x, y); + T Test2 = max(z, w); + + vecType Result(uninitialize); + for(length_t i = 0, n = Result.length(); i < n; ++i) + { + U Result1 = x > y ? a[i] : b[i]; + U Result2 = z > w ? c[i] : d[i]; + Result[i] = Test1 > Test2 ? Result1 : Result2; + } + return Result; +} + +// Max comparison between 4 variables +template class vecType> +GLM_FUNC_QUALIFIER vecType associatedMax +( + vecType const & x, U a, + vecType const & y, U b, + vecType const & z, U c, + vecType const & w, U d +) +{ + vecType Result(uninitialize); + for(length_t i = 0, n = Result.length(); i < n; ++i) + { + T Test1 = max(x[i], y[i]); + T Test2 = max(z[i], w[i]);; + U Result1 = x[i] > y[i] ? a : b; + U Result2 = z[i] > w[i] ? c : d; + Result[i] = Test1 > Test2 ? Result1 : Result2; + } + return Result; +} +}//namespace glm diff --git a/external/include/glm/gtx/bit.hpp b/external/include/glm/gtx/bit.hpp new file mode 100644 index 0000000..17378f3 --- /dev/null +++ b/external/include/glm/gtx/bit.hpp @@ -0,0 +1,95 @@ +/// @ref gtx_bit +/// @file glm/gtx/bit.hpp +/// +/// @see core (dependence) +/// @see gtc_half_float (dependence) +/// +/// @defgroup gtx_bit GLM_GTX_bit +/// @ingroup gtx +/// +/// @brief Allow to perform bit operations on integer values +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependencies +#include "../gtc/bitfield.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_bit extension is deprecated, include GLM_GTC_bitfield and GLM_GTC_integer instead") +#endif + +namespace glm +{ + /// @addtogroup gtx_bit + /// @{ + + /// @see gtx_bit + template + GLM_FUNC_DECL genIUType highestBitValue(genIUType Value); + + /// @see gtx_bit + template + GLM_FUNC_DECL genIUType lowestBitValue(genIUType Value); + + /// Find the highest bit set to 1 in a integer variable and return its value. + /// + /// @see gtx_bit + template class vecType> + GLM_FUNC_DECL vecType highestBitValue(vecType const & value); + + /// Return the power of two number which value is just higher the input value. + /// Deprecated, use ceilPowerOfTwo from GTC_round instead + /// + /// @see gtc_round + /// @see gtx_bit + template + GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoAbove(genIUType Value); + + /// Return the power of two number which value is just higher the input value. + /// Deprecated, use ceilPowerOfTwo from GTC_round instead + /// + /// @see gtc_round + /// @see gtx_bit + template class vecType> + GLM_DEPRECATED GLM_FUNC_DECL vecType powerOfTwoAbove(vecType const & value); + + /// Return the power of two number which value is just lower the input value. + /// Deprecated, use floorPowerOfTwo from GTC_round instead + /// + /// @see gtc_round + /// @see gtx_bit + template + GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoBelow(genIUType Value); + + /// Return the power of two number which value is just lower the input value. + /// Deprecated, use floorPowerOfTwo from GTC_round instead + /// + /// @see gtc_round + /// @see gtx_bit + template class vecType> + GLM_DEPRECATED GLM_FUNC_DECL vecType powerOfTwoBelow(vecType const & value); + + /// Return the power of two number which value is the closet to the input value. + /// Deprecated, use roundPowerOfTwo from GTC_round instead + /// + /// @see gtc_round + /// @see gtx_bit + template + GLM_DEPRECATED GLM_FUNC_DECL genIUType powerOfTwoNearest(genIUType Value); + + /// Return the power of two number which value is the closet to the input value. + /// Deprecated, use roundPowerOfTwo from GTC_round instead + /// + /// @see gtc_round + /// @see gtx_bit + template class vecType> + GLM_DEPRECATED GLM_FUNC_DECL vecType powerOfTwoNearest(vecType const & value); + + /// @} +} //namespace glm + + +#include "bit.inl" + diff --git a/external/include/glm/gtx/bit.inl b/external/include/glm/gtx/bit.inl new file mode 100644 index 0000000..10d5f7f --- /dev/null +++ b/external/include/glm/gtx/bit.inl @@ -0,0 +1,93 @@ +/// @ref gtx_bit +/// @file glm/gtx/bit.inl + +namespace glm +{ + /////////////////// + // highestBitValue + + template + GLM_FUNC_QUALIFIER genIUType highestBitValue(genIUType Value) + { + genIUType tmp = Value; + genIUType result = genIUType(0); + while(tmp) + { + result = (tmp & (~tmp + 1)); // grab lowest bit + tmp &= ~result; // clear lowest bit + } + return result; + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType highestBitValue(vecType const & v) + { + return detail::functor1::call(highestBitValue, v); + } + + /////////////////// + // lowestBitValue + + template + GLM_FUNC_QUALIFIER genIUType lowestBitValue(genIUType Value) + { + return (Value & (~Value + 1)); + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType lowestBitValue(vecType const & v) + { + return detail::functor1::call(lowestBitValue, v); + } + + /////////////////// + // powerOfTwoAbove + + template + GLM_FUNC_QUALIFIER genType powerOfTwoAbove(genType value) + { + return isPowerOfTwo(value) ? value : highestBitValue(value) << 1; + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType powerOfTwoAbove(vecType const & v) + { + return detail::functor1::call(powerOfTwoAbove, v); + } + + /////////////////// + // powerOfTwoBelow + + template + GLM_FUNC_QUALIFIER genType powerOfTwoBelow(genType value) + { + return isPowerOfTwo(value) ? value : highestBitValue(value); + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType powerOfTwoBelow(vecType const & v) + { + return detail::functor1::call(powerOfTwoBelow, v); + } + + ///////////////////// + // powerOfTwoNearest + + template + GLM_FUNC_QUALIFIER genType powerOfTwoNearest(genType value) + { + if(isPowerOfTwo(value)) + return value; + + genType const prev = highestBitValue(value); + genType const next = prev << 1; + return (next - value) < (value - prev) ? next : prev; + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType powerOfTwoNearest(vecType const & v) + { + return detail::functor1::call(powerOfTwoNearest, v); + } + +}//namespace glm diff --git a/external/include/glm/gtx/closest_point.hpp b/external/include/glm/gtx/closest_point.hpp new file mode 100644 index 0000000..8d435b8 --- /dev/null +++ b/external/include/glm/gtx/closest_point.hpp @@ -0,0 +1,45 @@ +/// @ref gtx_closest_point +/// @file glm/gtx/closest_point.hpp +/// +/// @see core (dependence) +/// +/// @defgroup gtx_closest_point GLM_GTX_closest_point +/// @ingroup gtx +/// +/// @brief Find the point on a straight line which is the closet of a point. +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../glm.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_closest_point extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_closest_point + /// @{ + + /// Find the point on a straight line which is the closet of a point. + /// @see gtx_closest_point + template + GLM_FUNC_DECL tvec3 closestPointOnLine( + tvec3 const & point, + tvec3 const & a, + tvec3 const & b); + + /// 2d lines work as well + template + GLM_FUNC_DECL tvec2 closestPointOnLine( + tvec2 const & point, + tvec2 const & a, + tvec2 const & b); + + /// @} +}// namespace glm + +#include "closest_point.inl" diff --git a/external/include/glm/gtx/closest_point.inl b/external/include/glm/gtx/closest_point.inl new file mode 100644 index 0000000..ccda9ab --- /dev/null +++ b/external/include/glm/gtx/closest_point.inl @@ -0,0 +1,46 @@ +/// @ref gtx_closest_point +/// @file glm/gtx/closest_point.inl + +namespace glm +{ + template + GLM_FUNC_QUALIFIER tvec3 closestPointOnLine + ( + tvec3 const & point, + tvec3 const & a, + tvec3 const & b + ) + { + T LineLength = distance(a, b); + tvec3 Vector = point - a; + tvec3 LineDirection = (b - a) / LineLength; + + // Project Vector3 to LineDirection to get the distance of point from a + T Distance = dot(Vector, LineDirection); + + if(Distance <= T(0)) return a; + if(Distance >= LineLength) return b; + return a + LineDirection * Distance; + } + + template + GLM_FUNC_QUALIFIER tvec2 closestPointOnLine + ( + tvec2 const & point, + tvec2 const & a, + tvec2 const & b + ) + { + T LineLength = distance(a, b); + tvec2 Vector = point - a; + tvec2 LineDirection = (b - a) / LineLength; + + // Project Vector3 to LineDirection to get the distance of point from a + T Distance = dot(Vector3, LineDirection); + + if(Distance <= T(0)) return a; + if(Distance >= LineLength) return b; + return a + LineDirection * Distance; + } + +}//namespace glm diff --git a/external/include/glm/gtx/color_space.hpp b/external/include/glm/gtx/color_space.hpp new file mode 100644 index 0000000..9ff08dc --- /dev/null +++ b/external/include/glm/gtx/color_space.hpp @@ -0,0 +1,68 @@ +/// @ref gtx_color_space +/// @file glm/gtx/color_space.hpp +/// +/// @see core (dependence) +/// +/// @defgroup gtx_color_space GLM_GTX_color_space +/// @ingroup gtx +/// +/// @brief Related to RGB to HSV conversions and operations. +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../glm.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_color_space extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_color_space + /// @{ + + /// Converts a color from HSV color space to its color in RGB color space. + /// @see gtx_color_space + template + GLM_FUNC_DECL tvec3 rgbColor( + tvec3 const & hsvValue); + + /// Converts a color from RGB color space to its color in HSV color space. + /// @see gtx_color_space + template + GLM_FUNC_DECL tvec3 hsvColor( + tvec3 const & rgbValue); + + /// Build a saturation matrix. + /// @see gtx_color_space + template + GLM_FUNC_DECL tmat4x4 saturation( + T const s); + + /// Modify the saturation of a color. + /// @see gtx_color_space + template + GLM_FUNC_DECL tvec3 saturation( + T const s, + tvec3 const & color); + + /// Modify the saturation of a color. + /// @see gtx_color_space + template + GLM_FUNC_DECL tvec4 saturation( + T const s, + tvec4 const & color); + + /// Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals. + /// @see gtx_color_space + template + GLM_FUNC_DECL T luminosity( + tvec3 const & color); + + /// @} +}//namespace glm + +#include "color_space.inl" diff --git a/external/include/glm/gtx/color_space.inl b/external/include/glm/gtx/color_space.inl new file mode 100644 index 0000000..e7cd58d --- /dev/null +++ b/external/include/glm/gtx/color_space.inl @@ -0,0 +1,141 @@ +/// @ref gtx_color_space +/// @file glm/gtx/color_space.inl + +namespace glm +{ + template + GLM_FUNC_QUALIFIER tvec3 rgbColor(const tvec3& hsvColor) + { + tvec3 hsv = hsvColor; + tvec3 rgbColor; + + if(hsv.y == static_cast(0)) + // achromatic (grey) + rgbColor = tvec3(hsv.z); + else + { + T sector = floor(hsv.x / T(60)); + T frac = (hsv.x / T(60)) - sector; + // factorial part of h + T o = hsv.z * (T(1) - hsv.y); + T p = hsv.z * (T(1) - hsv.y * frac); + T q = hsv.z * (T(1) - hsv.y * (T(1) - frac)); + + switch(int(sector)) + { + default: + case 0: + rgbColor.r = hsv.z; + rgbColor.g = q; + rgbColor.b = o; + break; + case 1: + rgbColor.r = p; + rgbColor.g = hsv.z; + rgbColor.b = o; + break; + case 2: + rgbColor.r = o; + rgbColor.g = hsv.z; + rgbColor.b = q; + break; + case 3: + rgbColor.r = o; + rgbColor.g = p; + rgbColor.b = hsv.z; + break; + case 4: + rgbColor.r = q; + rgbColor.g = o; + rgbColor.b = hsv.z; + break; + case 5: + rgbColor.r = hsv.z; + rgbColor.g = o; + rgbColor.b = p; + break; + } + } + + return rgbColor; + } + + template + GLM_FUNC_QUALIFIER tvec3 hsvColor(const tvec3& rgbColor) + { + tvec3 hsv = rgbColor; + float Min = min(min(rgbColor.r, rgbColor.g), rgbColor.b); + float Max = max(max(rgbColor.r, rgbColor.g), rgbColor.b); + float Delta = Max - Min; + + hsv.z = Max; + + if(Max != static_cast(0)) + { + hsv.y = Delta / hsv.z; + T h = static_cast(0); + + if(rgbColor.r == Max) + // between yellow & magenta + h = static_cast(0) + T(60) * (rgbColor.g - rgbColor.b) / Delta; + else if(rgbColor.g == Max) + // between cyan & yellow + h = static_cast(120) + T(60) * (rgbColor.b - rgbColor.r) / Delta; + else + // between magenta & cyan + h = static_cast(240) + T(60) * (rgbColor.r - rgbColor.g) / Delta; + + if(h < T(0)) + hsv.x = h + T(360); + else + hsv.x = h; + } + else + { + // If r = g = b = 0 then s = 0, h is undefined + hsv.y = static_cast(0); + hsv.x = static_cast(0); + } + + return hsv; + } + + template + GLM_FUNC_QUALIFIER tmat4x4 saturation(T const s) + { + tvec3 rgbw = tvec3(T(0.2126), T(0.7152), T(0.0722)); + + tvec3 const col((T(1) - s) * rgbw); + + tmat4x4 result(T(1)); + result[0][0] = col.x + s; + result[0][1] = col.x; + result[0][2] = col.x; + result[1][0] = col.y; + result[1][1] = col.y + s; + result[1][2] = col.y; + result[2][0] = col.z; + result[2][1] = col.z; + result[2][2] = col.z + s; + return result; + } + + template + GLM_FUNC_QUALIFIER tvec3 saturation(const T s, const tvec3& color) + { + return tvec3(saturation(s) * tvec4(color, T(0))); + } + + template + GLM_FUNC_QUALIFIER tvec4 saturation(const T s, const tvec4& color) + { + return saturation(s) * color; + } + + template + GLM_FUNC_QUALIFIER T luminosity(const tvec3& color) + { + const tvec3 tmp = tvec3(0.33, 0.59, 0.11); + return dot(color, tmp); + } +}//namespace glm diff --git a/external/include/glm/gtx/color_space_YCoCg.hpp b/external/include/glm/gtx/color_space_YCoCg.hpp new file mode 100644 index 0000000..428ca6d --- /dev/null +++ b/external/include/glm/gtx/color_space_YCoCg.hpp @@ -0,0 +1,56 @@ +/// @ref gtx_color_space_YCoCg +/// @file glm/gtx/color_space_YCoCg.hpp +/// +/// @see core (dependence) +/// +/// @defgroup gtx_color_space_YCoCg GLM_GTX_color_space_YCoCg +/// @ingroup gtx +/// +/// @brief RGB to YCoCg conversions and operations +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../glm.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_color_space_YCoCg extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_color_space_YCoCg + /// @{ + + /// Convert a color from RGB color space to YCoCg color space. + /// @see gtx_color_space_YCoCg + template + GLM_FUNC_DECL tvec3 rgb2YCoCg( + tvec3 const & rgbColor); + + /// Convert a color from YCoCg color space to RGB color space. + /// @see gtx_color_space_YCoCg + template + GLM_FUNC_DECL tvec3 YCoCg2rgb( + tvec3 const & YCoCgColor); + + /// Convert a color from RGB color space to YCoCgR color space. + /// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range" + /// @see gtx_color_space_YCoCg + template + GLM_FUNC_DECL tvec3 rgb2YCoCgR( + tvec3 const & rgbColor); + + /// Convert a color from YCoCgR color space to RGB color space. + /// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range" + /// @see gtx_color_space_YCoCg + template + GLM_FUNC_DECL tvec3 YCoCgR2rgb( + tvec3 const & YCoCgColor); + + /// @} +}//namespace glm + +#include "color_space_YCoCg.inl" diff --git a/external/include/glm/gtx/color_space_YCoCg.inl b/external/include/glm/gtx/color_space_YCoCg.inl new file mode 100644 index 0000000..1ca2e5b --- /dev/null +++ b/external/include/glm/gtx/color_space_YCoCg.inl @@ -0,0 +1,108 @@ +/// @ref gtx_color_space_YCoCg +/// @file glm/gtx/color_space_YCoCg.inl + +namespace glm +{ + template + GLM_FUNC_QUALIFIER tvec3 rgb2YCoCg + ( + tvec3 const & rgbColor + ) + { + tvec3 result; + result.x/*Y */ = rgbColor.r / T(4) + rgbColor.g / T(2) + rgbColor.b / T(4); + result.y/*Co*/ = rgbColor.r / T(2) + rgbColor.g * T(0) - rgbColor.b / T(2); + result.z/*Cg*/ = - rgbColor.r / T(4) + rgbColor.g / T(2) - rgbColor.b / T(4); + return result; + } + + template + GLM_FUNC_QUALIFIER tvec3 YCoCg2rgb + ( + tvec3 const & YCoCgColor + ) + { + tvec3 result; + result.r = YCoCgColor.x + YCoCgColor.y - YCoCgColor.z; + result.g = YCoCgColor.x + YCoCgColor.z; + result.b = YCoCgColor.x - YCoCgColor.y - YCoCgColor.z; + return result; + } + + template + class compute_YCoCgR { + public: + static GLM_FUNC_QUALIFIER tvec3 rgb2YCoCgR + ( + tvec3 const & rgbColor + ) + { + tvec3 result; + result.x/*Y */ = rgbColor.g / T(2) + (rgbColor.r + rgbColor.b) / T(4); + result.y/*Co*/ = rgbColor.r - rgbColor.b; + result.z/*Cg*/ = rgbColor.g - (rgbColor.r + rgbColor.b) / T(2); + return result; + } + + static GLM_FUNC_QUALIFIER tvec3 YCoCgR2rgb + ( + tvec3 const & YCoCgRColor + ) + { + tvec3 result; + T tmp = YCoCgRColor.x - (YCoCgRColor.z / T(2)); + result.g = YCoCgRColor.z + tmp; + result.b = tmp - (YCoCgRColor.y / T(2)); + result.r = result.b + YCoCgRColor.y; + return result; + } + }; + + template + class compute_YCoCgR { + public: + static GLM_FUNC_QUALIFIER tvec3 rgb2YCoCgR + ( + tvec3 const & rgbColor + ) + { + tvec3 result; + result.y/*Co*/ = rgbColor.r - rgbColor.b; + T tmp = rgbColor.b + (result.y >> 1); + result.z/*Cg*/ = rgbColor.g - tmp; + result.x/*Y */ = tmp + (result.z >> 1); + return result; + } + + static GLM_FUNC_QUALIFIER tvec3 YCoCgR2rgb + ( + tvec3 const & YCoCgRColor + ) + { + tvec3 result; + T tmp = YCoCgRColor.x - (YCoCgRColor.z >> 1); + result.g = YCoCgRColor.z + tmp; + result.b = tmp - (YCoCgRColor.y >> 1); + result.r = result.b + YCoCgRColor.y; + return result; + } + }; + + template + GLM_FUNC_QUALIFIER tvec3 rgb2YCoCgR + ( + tvec3 const & rgbColor + ) + { + return compute_YCoCgR::is_integer>::rgb2YCoCgR(rgbColor); + } + + template + GLM_FUNC_QUALIFIER tvec3 YCoCgR2rgb + ( + tvec3 const & YCoCgRColor + ) + { + return compute_YCoCgR::is_integer>::YCoCgR2rgb(YCoCgRColor); + } +}//namespace glm diff --git a/external/include/glm/gtx/common.hpp b/external/include/glm/gtx/common.hpp new file mode 100644 index 0000000..6533a54 --- /dev/null +++ b/external/include/glm/gtx/common.hpp @@ -0,0 +1,53 @@ +/// @ref gtx_common +/// @file glm/gtx/common.hpp +/// +/// @see core (dependence) +/// @see gtc_half_float (dependence) +/// +/// @defgroup gtx_common GLM_GTX_common +/// @ingroup gtx +/// +/// @brief Provide functions to increase the compatibility with Cg and HLSL languages +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependencies: +#include "../vec2.hpp" +#include "../vec3.hpp" +#include "../vec4.hpp" +#include "../gtc/vec1.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_common extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_common + /// @{ + + /// Returns true if x is a denormalized number + /// Numbers whose absolute value is too small to be represented in the normal format are represented in an alternate, denormalized format. + /// This format is less precise but can represent values closer to zero. + /// + /// @tparam genType Floating-point scalar or vector types. + /// + /// @see GLSL isnan man page + /// @see GLSL 4.20.8 specification, section 8.3 Common Functions + template + GLM_FUNC_DECL typename genType::bool_type isdenormal(genType const & x); + + /// Similar to 'mod' but with a different rounding and integer support. + /// Returns 'x - y * trunc(x/y)' instead of 'x - y * floor(x/y)' + /// + /// @see GLSL mod vs HLSL fmod + /// @see GLSL mod man page + template class vecType> + GLM_FUNC_DECL vecType fmod(vecType const & v); + + /// @} +}//namespace glm + +#include "common.inl" diff --git a/external/include/glm/gtx/common.inl b/external/include/glm/gtx/common.inl new file mode 100644 index 0000000..6c9cb65 --- /dev/null +++ b/external/include/glm/gtx/common.inl @@ -0,0 +1,112 @@ +/// @ref gtx_common +/// @file glm/gtx/common.inl + +#include + +namespace glm{ +namespace detail +{ + template class vecType, bool isFloat = true> + struct compute_fmod + { + GLM_FUNC_QUALIFIER static vecType call(vecType const & a, vecType const & b) + { + return detail::functor2::call(std::fmod, a, b); + } + }; + + template class vecType> + struct compute_fmod + { + GLM_FUNC_QUALIFIER static vecType call(vecType const & a, vecType const & b) + { + return a % b; + } + }; +}//namespace detail + + template + GLM_FUNC_QUALIFIER bool isdenormal(T const & x) + { + GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isdenormal' only accept floating-point inputs"); + +# if GLM_HAS_CXX11_STL + return std::fpclassify(x) == FP_SUBNORMAL; +# else + return x != static_cast(0) && std::fabs(x) < std::numeric_limits::min(); +# endif + } + + template + GLM_FUNC_QUALIFIER typename tvec1::bool_type isdenormal + ( + tvec1 const & x + ) + { + GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isdenormal' only accept floating-point inputs"); + + return typename tvec1::bool_type( + isdenormal(x.x)); + } + + template + GLM_FUNC_QUALIFIER typename tvec2::bool_type isdenormal + ( + tvec2 const & x + ) + { + GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isdenormal' only accept floating-point inputs"); + + return typename tvec2::bool_type( + isdenormal(x.x), + isdenormal(x.y)); + } + + template + GLM_FUNC_QUALIFIER typename tvec3::bool_type isdenormal + ( + tvec3 const & x + ) + { + GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isdenormal' only accept floating-point inputs"); + + return typename tvec3::bool_type( + isdenormal(x.x), + isdenormal(x.y), + isdenormal(x.z)); + } + + template + GLM_FUNC_QUALIFIER typename tvec4::bool_type isdenormal + ( + tvec4 const & x + ) + { + GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isdenormal' only accept floating-point inputs"); + + return typename tvec4::bool_type( + isdenormal(x.x), + isdenormal(x.y), + isdenormal(x.z), + isdenormal(x.w)); + } + + // fmod + template + GLM_FUNC_QUALIFIER genType fmod(genType x, genType y) + { + return fmod(tvec1(x), y).x; + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType fmod(vecType const & x, T y) + { + return detail::compute_fmod::is_iec559>::call(x, vecType(y)); + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType fmod(vecType const & x, vecType const & y) + { + return detail::compute_fmod::is_iec559>::call(x, y); + } +}//namespace glm diff --git a/external/include/glm/gtx/compatibility.hpp b/external/include/glm/gtx/compatibility.hpp new file mode 100644 index 0000000..9f4819a --- /dev/null +++ b/external/include/glm/gtx/compatibility.hpp @@ -0,0 +1,130 @@ +/// @ref gtx_compatibility +/// @file glm/gtx/compatibility.hpp +/// +/// @see core (dependence) +/// @see gtc_half_float (dependence) +/// +/// @defgroup gtx_compatibility GLM_GTX_compatibility +/// @ingroup gtx +/// +/// @brief Provide functions to increase the compatibility with Cg and HLSL languages +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../glm.hpp" +#include "../gtc/quaternion.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_compatibility extension included") +#endif + +#if GLM_COMPILER & GLM_COMPILER_VC +# include +#elif GLM_COMPILER & GLM_COMPILER_GCC +# include +# if(GLM_PLATFORM & GLM_PLATFORM_ANDROID) +# undef isfinite +# endif +#endif//GLM_COMPILER + +namespace glm +{ + /// @addtogroup gtx_compatibility + /// @{ + + template GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility) + template GLM_FUNC_QUALIFIER tvec2 lerp(const tvec2& x, const tvec2& y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility) + + template GLM_FUNC_QUALIFIER tvec3 lerp(const tvec3& x, const tvec3& y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility) + template GLM_FUNC_QUALIFIER tvec4 lerp(const tvec4& x, const tvec4& y, T a){return mix(x, y, a);} //!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility) + template GLM_FUNC_QUALIFIER tvec2 lerp(const tvec2& x, const tvec2& y, const tvec2& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility) + template GLM_FUNC_QUALIFIER tvec3 lerp(const tvec3& x, const tvec3& y, const tvec3& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility) + template GLM_FUNC_QUALIFIER tvec4 lerp(const tvec4& x, const tvec4& y, const tvec4& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility) + + template GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility) + template GLM_FUNC_QUALIFIER tvec2 saturate(const tvec2& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility) + template GLM_FUNC_QUALIFIER tvec3 saturate(const tvec3& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility) + template GLM_FUNC_QUALIFIER tvec4 saturate(const tvec4& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility) + + template GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility) + template GLM_FUNC_QUALIFIER tvec2 atan2(const tvec2& x, const tvec2& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility) + template GLM_FUNC_QUALIFIER tvec3 atan2(const tvec3& x, const tvec3& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility) + template GLM_FUNC_QUALIFIER tvec4 atan2(const tvec4& x, const tvec4& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility) + + template GLM_FUNC_DECL bool isfinite(genType const & x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) + template GLM_FUNC_DECL tvec1 isfinite(const tvec1& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) + template GLM_FUNC_DECL tvec2 isfinite(const tvec2& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) + template GLM_FUNC_DECL tvec3 isfinite(const tvec3& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) + template GLM_FUNC_DECL tvec4 isfinite(const tvec4& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) + + typedef bool bool1; //!< \brief boolean type with 1 component. (From GLM_GTX_compatibility extension) + typedef tvec2 bool2; //!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension) + typedef tvec3 bool3; //!< \brief boolean type with 3 components. (From GLM_GTX_compatibility extension) + typedef tvec4 bool4; //!< \brief boolean type with 4 components. (From GLM_GTX_compatibility extension) + + typedef bool bool1x1; //!< \brief boolean matrix with 1 x 1 component. (From GLM_GTX_compatibility extension) + typedef tmat2x2 bool2x2; //!< \brief boolean matrix with 2 x 2 components. (From GLM_GTX_compatibility extension) + typedef tmat2x3 bool2x3; //!< \brief boolean matrix with 2 x 3 components. (From GLM_GTX_compatibility extension) + typedef tmat2x4 bool2x4; //!< \brief boolean matrix with 2 x 4 components. (From GLM_GTX_compatibility extension) + typedef tmat3x2 bool3x2; //!< \brief boolean matrix with 3 x 2 components. (From GLM_GTX_compatibility extension) + typedef tmat3x3 bool3x3; //!< \brief boolean matrix with 3 x 3 components. (From GLM_GTX_compatibility extension) + typedef tmat3x4 bool3x4; //!< \brief boolean matrix with 3 x 4 components. (From GLM_GTX_compatibility extension) + typedef tmat4x2 bool4x2; //!< \brief boolean matrix with 4 x 2 components. (From GLM_GTX_compatibility extension) + typedef tmat4x3 bool4x3; //!< \brief boolean matrix with 4 x 3 components. (From GLM_GTX_compatibility extension) + typedef tmat4x4 bool4x4; //!< \brief boolean matrix with 4 x 4 components. (From GLM_GTX_compatibility extension) + + typedef int int1; //!< \brief integer vector with 1 component. (From GLM_GTX_compatibility extension) + typedef tvec2 int2; //!< \brief integer vector with 2 components. (From GLM_GTX_compatibility extension) + typedef tvec3 int3; //!< \brief integer vector with 3 components. (From GLM_GTX_compatibility extension) + typedef tvec4 int4; //!< \brief integer vector with 4 components. (From GLM_GTX_compatibility extension) + + typedef int int1x1; //!< \brief integer matrix with 1 component. (From GLM_GTX_compatibility extension) + typedef tmat2x2 int2x2; //!< \brief integer matrix with 2 x 2 components. (From GLM_GTX_compatibility extension) + typedef tmat2x3 int2x3; //!< \brief integer matrix with 2 x 3 components. (From GLM_GTX_compatibility extension) + typedef tmat2x4 int2x4; //!< \brief integer matrix with 2 x 4 components. (From GLM_GTX_compatibility extension) + typedef tmat3x2 int3x2; //!< \brief integer matrix with 3 x 2 components. (From GLM_GTX_compatibility extension) + typedef tmat3x3 int3x3; //!< \brief integer matrix with 3 x 3 components. (From GLM_GTX_compatibility extension) + typedef tmat3x4 int3x4; //!< \brief integer matrix with 3 x 4 components. (From GLM_GTX_compatibility extension) + typedef tmat4x2 int4x2; //!< \brief integer matrix with 4 x 2 components. (From GLM_GTX_compatibility extension) + typedef tmat4x3 int4x3; //!< \brief integer matrix with 4 x 3 components. (From GLM_GTX_compatibility extension) + typedef tmat4x4 int4x4; //!< \brief integer matrix with 4 x 4 components. (From GLM_GTX_compatibility extension) + + typedef float float1; //!< \brief single-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension) + typedef tvec2 float2; //!< \brief single-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension) + typedef tvec3 float3; //!< \brief single-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension) + typedef tvec4 float4; //!< \brief single-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension) + + typedef float float1x1; //!< \brief single-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension) + typedef tmat2x2 float2x2; //!< \brief single-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension) + typedef tmat2x3 float2x3; //!< \brief single-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension) + typedef tmat2x4 float2x4; //!< \brief single-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension) + typedef tmat3x2 float3x2; //!< \brief single-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension) + typedef tmat3x3 float3x3; //!< \brief single-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension) + typedef tmat3x4 float3x4; //!< \brief single-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension) + typedef tmat4x2 float4x2; //!< \brief single-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension) + typedef tmat4x3 float4x3; //!< \brief single-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension) + typedef tmat4x4 float4x4; //!< \brief single-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension) + + typedef double double1; //!< \brief double-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension) + typedef tvec2 double2; //!< \brief double-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension) + typedef tvec3 double3; //!< \brief double-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension) + typedef tvec4 double4; //!< \brief double-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension) + + typedef double double1x1; //!< \brief double-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension) + typedef tmat2x2 double2x2; //!< \brief double-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension) + typedef tmat2x3 double2x3; //!< \brief double-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension) + typedef tmat2x4 double2x4; //!< \brief double-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension) + typedef tmat3x2 double3x2; //!< \brief double-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension) + typedef tmat3x3 double3x3; //!< \brief double-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension) + typedef tmat3x4 double3x4; //!< \brief double-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension) + typedef tmat4x2 double4x2; //!< \brief double-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension) + typedef tmat4x3 double4x3; //!< \brief double-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension) + typedef tmat4x4 double4x4; //!< \brief double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension) + + /// @} +}//namespace glm + +#include "compatibility.inl" diff --git a/external/include/glm/gtx/compatibility.inl b/external/include/glm/gtx/compatibility.inl new file mode 100644 index 0000000..368527a --- /dev/null +++ b/external/include/glm/gtx/compatibility.inl @@ -0,0 +1,65 @@ +/// @ref gtx_compatibility +/// @file glm/gtx/compatibility.inl + +#include + +namespace glm +{ + // isfinite + template + GLM_FUNC_QUALIFIER bool isfinite( + genType const & x) + { +# if GLM_HAS_CXX11_STL + return std::isfinite(x) != 0; +# elif GLM_COMPILER & GLM_COMPILER_VC + return _finite(x); +# elif GLM_COMPILER & GLM_COMPILER_GCC && GLM_PLATFORM & GLM_PLATFORM_ANDROID + return _isfinite(x) != 0; +# else + if (std::numeric_limits::is_integer || std::denorm_absent == std::numeric_limits::has_denorm) + return std::numeric_limits::min() <= x && std::numeric_limits::max() >= x; + else + return -std::numeric_limits::max() <= x && std::numeric_limits::max() >= x; +# endif + } + + template + GLM_FUNC_QUALIFIER tvec1 isfinite( + tvec1 const & x) + { + return tvec1( + isfinite(x.x)); + } + + template + GLM_FUNC_QUALIFIER tvec2 isfinite( + tvec2 const & x) + { + return tvec2( + isfinite(x.x), + isfinite(x.y)); + } + + template + GLM_FUNC_QUALIFIER tvec3 isfinite( + tvec3 const & x) + { + return tvec3( + isfinite(x.x), + isfinite(x.y), + isfinite(x.z)); + } + + template + GLM_FUNC_QUALIFIER tvec4 isfinite( + tvec4 const & x) + { + return tvec4( + isfinite(x.x), + isfinite(x.y), + isfinite(x.z), + isfinite(x.w)); + } + +}//namespace glm diff --git a/external/include/glm/gtx/component_wise.hpp b/external/include/glm/gtx/component_wise.hpp new file mode 100644 index 0000000..c316f9e --- /dev/null +++ b/external/include/glm/gtx/component_wise.hpp @@ -0,0 +1,65 @@ +/// @ref gtx_component_wise +/// @file glm/gtx/component_wise.hpp +/// @date 2007-05-21 / 2011-06-07 +/// @author Christophe Riccio +/// +/// @see core (dependence) +/// +/// @defgroup gtx_component_wise GLM_GTX_component_wise +/// @ingroup gtx +/// +/// @brief Operations between components of a type +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependencies +#include "../detail/setup.hpp" +#include "../detail/precision.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_component_wise extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_component_wise + /// @{ + + /// Convert an integer vector to a normalized float vector. + /// If the parameter value type is already a floating precision type, the value is passed through. + /// @see gtx_component_wise + template class vecType> + GLM_FUNC_DECL vecType compNormalize(vecType const & v); + + /// Convert a normalized float vector to an integer vector. + /// If the parameter value type is already a floating precision type, the value is passed through. + /// @see gtx_component_wise + template class vecType> + GLM_FUNC_DECL vecType compScale(vecType const & v); + + /// Add all vector components together. + /// @see gtx_component_wise + template + GLM_FUNC_DECL typename genType::value_type compAdd(genType const & v); + + /// Multiply all vector components together. + /// @see gtx_component_wise + template + GLM_FUNC_DECL typename genType::value_type compMul(genType const & v); + + /// Find the minimum value between single vector components. + /// @see gtx_component_wise + template + GLM_FUNC_DECL typename genType::value_type compMin(genType const & v); + + /// Find the maximum value between single vector components. + /// @see gtx_component_wise + template + GLM_FUNC_DECL typename genType::value_type compMax(genType const & v); + + /// @} +}//namespace glm + +#include "component_wise.inl" diff --git a/external/include/glm/gtx/component_wise.inl b/external/include/glm/gtx/component_wise.inl new file mode 100644 index 0000000..add3969 --- /dev/null +++ b/external/include/glm/gtx/component_wise.inl @@ -0,0 +1,128 @@ +/// @ref gtx_component_wise +/// @file glm/gtx/component_wise.inl + +#include + +namespace glm{ +namespace detail +{ + template class vecType, bool isInteger, bool signedType> + struct compute_compNormalize + {}; + + template class vecType> + struct compute_compNormalize + { + GLM_FUNC_QUALIFIER static vecType call(vecType const & v) + { + floatType const Min = static_cast(std::numeric_limits::min()); + floatType const Max = static_cast(std::numeric_limits::max()); + return (vecType(v) - Min) / (Max - Min) * static_cast(2) - static_cast(1); + } + }; + + template class vecType> + struct compute_compNormalize + { + GLM_FUNC_QUALIFIER static vecType call(vecType const & v) + { + return vecType(v) / static_cast(std::numeric_limits::max()); + } + }; + + template class vecType> + struct compute_compNormalize + { + GLM_FUNC_QUALIFIER static vecType call(vecType const & v) + { + return v; + } + }; + + template class vecType, bool isInteger, bool signedType> + struct compute_compScale + {}; + + template class vecType> + struct compute_compScale + { + GLM_FUNC_QUALIFIER static vecType call(vecType const & v) + { + floatType const Max = static_cast(std::numeric_limits::max()) + static_cast(0.5); + vecType const Scaled(v * Max); + vecType const Result(Scaled - static_cast(0.5)); + return Result; + } + }; + + template class vecType> + struct compute_compScale + { + GLM_FUNC_QUALIFIER static vecType call(vecType const & v) + { + return vecType(vecType(v) * static_cast(std::numeric_limits::max())); + } + }; + + template class vecType> + struct compute_compScale + { + GLM_FUNC_QUALIFIER static vecType call(vecType const & v) + { + return v; + } + }; +}//namespace detail + + template class vecType> + GLM_FUNC_QUALIFIER vecType compNormalize(vecType const & v) + { + GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'compNormalize' accepts only floating-point types for 'floatType' template parameter"); + + return detail::compute_compNormalize::is_integer, std::numeric_limits::is_signed>::call(v); + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType compScale(vecType const & v) + { + GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'compScale' accepts only floating-point types for 'floatType' template parameter"); + + return detail::compute_compScale::is_integer, std::numeric_limits::is_signed>::call(v); + } + + template class vecType> + GLM_FUNC_QUALIFIER T compAdd(vecType const & v) + { + T Result(0); + for(length_t i = 0, n = v.length(); i < n; ++i) + Result += v[i]; + return Result; + } + + template class vecType> + GLM_FUNC_QUALIFIER T compMul(vecType const & v) + { + T Result(1); + for(length_t i = 0, n = v.length(); i < n; ++i) + Result *= v[i]; + return Result; + } + + template class vecType> + GLM_FUNC_QUALIFIER T compMin(vecType const & v) + { + T Result(v[0]); + for(length_t i = 1, n = v.length(); i < n; ++i) + Result = min(Result, v[i]); + return Result; + } + + template class vecType> + GLM_FUNC_QUALIFIER T compMax(vecType const & v) + { + T Result(v[0]); + for(length_t i = 1, n = v.length(); i < n; ++i) + Result = max(Result, v[i]); + return Result; + } +}//namespace glm diff --git a/external/include/glm/gtx/dual_quaternion.hpp b/external/include/glm/gtx/dual_quaternion.hpp new file mode 100644 index 0000000..4d7b61e --- /dev/null +++ b/external/include/glm/gtx/dual_quaternion.hpp @@ -0,0 +1,266 @@ +/// @ref gtx_dual_quaternion +/// @file glm/gtx/dual_quaternion.hpp +/// @author Maksim Vorobiev (msomeone@gmail.com) +/// +/// @see core (dependence) +/// @see gtc_half_float (dependence) +/// @see gtc_constants (dependence) +/// @see gtc_quaternion (dependence) +/// +/// @defgroup gtx_dual_quaternion GLM_GTX_dual_quaternion +/// @ingroup gtx +/// +/// @brief Defines a templated dual-quaternion type and several dual-quaternion operations. +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../glm.hpp" +#include "../gtc/constants.hpp" +#include "../gtc/quaternion.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_dual_quaternion extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_dual_quaternion + /// @{ + + template + struct tdualquat + { + // -- Implementation detail -- + + typedef T value_type; + typedef glm::tquat part_type; + + // -- Data -- + + glm::tquat real, dual; + + // -- Component accesses -- + + typedef length_t length_type; + /// Return the count of components of a dual quaternion + GLM_FUNC_DECL static length_type length(){return 2;} + + GLM_FUNC_DECL part_type & operator[](length_type i); + GLM_FUNC_DECL part_type const & operator[](length_type i) const; + + // -- Implicit basic constructors -- + + GLM_FUNC_DECL GLM_CONSTEXPR tdualquat() GLM_DEFAULT_CTOR; + GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tdualquat const & d) GLM_DEFAULT; + template + GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tdualquat const & d); + + // -- Explicit basic constructors -- + + GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit tdualquat(ctor); + GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tquat const & real); + GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tquat const & orientation, tvec3 const & translation); + GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tquat const & real, tquat const & dual); + + // -- Conversion constructors -- + + template + GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tdualquat(tdualquat const & q); + + GLM_FUNC_DECL GLM_EXPLICIT tdualquat(tmat2x4 const & holder_mat); + GLM_FUNC_DECL GLM_EXPLICIT tdualquat(tmat3x4 const & aug_mat); + + // -- Unary arithmetic operators -- + + GLM_FUNC_DECL tdualquat & operator=(tdualquat const & m) GLM_DEFAULT; + + template + GLM_FUNC_DECL tdualquat & operator=(tdualquat const & m); + template + GLM_FUNC_DECL tdualquat & operator*=(U s); + template + GLM_FUNC_DECL tdualquat & operator/=(U s); + }; + + // -- Unary bit operators -- + + template + GLM_FUNC_DECL tdualquat operator+(tdualquat const & q); + + template + GLM_FUNC_DECL tdualquat operator-(tdualquat const & q); + + // -- Binary operators -- + + template + GLM_FUNC_DECL tdualquat operator+(tdualquat const & q, tdualquat const & p); + + template + GLM_FUNC_DECL tdualquat operator*(tdualquat const & q, tdualquat const & p); + + template + GLM_FUNC_DECL tvec3 operator*(tdualquat const & q, tvec3 const & v); + + template + GLM_FUNC_DECL tvec3 operator*(tvec3 const & v, tdualquat const & q); + + template + GLM_FUNC_DECL tvec4 operator*(tdualquat const & q, tvec4 const & v); + + template + GLM_FUNC_DECL tvec4 operator*(tvec4 const & v, tdualquat const & q); + + template + GLM_FUNC_DECL tdualquat operator*(tdualquat const & q, T const & s); + + template + GLM_FUNC_DECL tdualquat operator*(T const & s, tdualquat const & q); + + template + GLM_FUNC_DECL tdualquat operator/(tdualquat const & q, T const & s); + + // -- Boolean operators -- + + template + GLM_FUNC_DECL bool operator==(tdualquat const & q1, tdualquat const & q2); + + template + GLM_FUNC_DECL bool operator!=(tdualquat const & q1, tdualquat const & q2); + + /// Returns the normalized quaternion. + /// + /// @see gtx_dual_quaternion + template + GLM_FUNC_DECL tdualquat normalize(tdualquat const & q); + + /// Returns the linear interpolation of two dual quaternion. + /// + /// @see gtc_dual_quaternion + template + GLM_FUNC_DECL tdualquat lerp(tdualquat const & x, tdualquat const & y, T const & a); + + /// Returns the q inverse. + /// + /// @see gtx_dual_quaternion + template + GLM_FUNC_DECL tdualquat inverse(tdualquat const & q); + + /// Converts a quaternion to a 2 * 4 matrix. + /// + /// @see gtx_dual_quaternion + template + GLM_FUNC_DECL tmat2x4 mat2x4_cast(tdualquat const & x); + + /// Converts a quaternion to a 3 * 4 matrix. + /// + /// @see gtx_dual_quaternion + template + GLM_FUNC_DECL tmat3x4 mat3x4_cast(tdualquat const & x); + + /// Converts a 2 * 4 matrix (matrix which holds real and dual parts) to a quaternion. + /// + /// @see gtx_dual_quaternion + template + GLM_FUNC_DECL tdualquat dualquat_cast(tmat2x4 const & x); + + /// Converts a 3 * 4 matrix (augmented matrix rotation + translation) to a quaternion. + /// + /// @see gtx_dual_quaternion + template + GLM_FUNC_DECL tdualquat dualquat_cast(tmat3x4 const & x); + + + /// Dual-quaternion of low single-precision floating-point numbers. + /// + /// @see gtx_dual_quaternion + typedef tdualquat lowp_dualquat; + + /// Dual-quaternion of medium single-precision floating-point numbers. + /// + /// @see gtx_dual_quaternion + typedef tdualquat mediump_dualquat; + + /// Dual-quaternion of high single-precision floating-point numbers. + /// + /// @see gtx_dual_quaternion + typedef tdualquat highp_dualquat; + + + /// Dual-quaternion of low single-precision floating-point numbers. + /// + /// @see gtx_dual_quaternion + typedef tdualquat lowp_fdualquat; + + /// Dual-quaternion of medium single-precision floating-point numbers. + /// + /// @see gtx_dual_quaternion + typedef tdualquat mediump_fdualquat; + + /// Dual-quaternion of high single-precision floating-point numbers. + /// + /// @see gtx_dual_quaternion + typedef tdualquat highp_fdualquat; + + + /// Dual-quaternion of low double-precision floating-point numbers. + /// + /// @see gtx_dual_quaternion + typedef tdualquat lowp_ddualquat; + + /// Dual-quaternion of medium double-precision floating-point numbers. + /// + /// @see gtx_dual_quaternion + typedef tdualquat mediump_ddualquat; + + /// Dual-quaternion of high double-precision floating-point numbers. + /// + /// @see gtx_dual_quaternion + typedef tdualquat highp_ddualquat; + + +#if(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT)) + /// Dual-quaternion of floating-point numbers. + /// + /// @see gtx_dual_quaternion + typedef highp_fdualquat dualquat; + + /// Dual-quaternion of single-precision floating-point numbers. + /// + /// @see gtx_dual_quaternion + typedef highp_fdualquat fdualquat; +#elif(defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT)) + typedef highp_fdualquat dualquat; + typedef highp_fdualquat fdualquat; +#elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT)) + typedef mediump_fdualquat dualquat; + typedef mediump_fdualquat fdualquat; +#elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && defined(GLM_PRECISION_LOWP_FLOAT)) + typedef lowp_fdualquat dualquat; + typedef lowp_fdualquat fdualquat; +#else +# error "GLM error: multiple default precision requested for single-precision floating-point types" +#endif + + +#if(!defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE)) + /// Dual-quaternion of default double-precision floating-point numbers. + /// + /// @see gtx_dual_quaternion + typedef highp_ddualquat ddualquat; +#elif(defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE)) + typedef highp_ddualquat ddualquat; +#elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE)) + typedef mediump_ddualquat ddualquat; +#elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && defined(GLM_PRECISION_LOWP_DOUBLE)) + typedef lowp_ddualquat ddualquat; +#else +# error "GLM error: Multiple default precision requested for double-precision floating-point types" +#endif + + /// @} +} //namespace glm + +#include "dual_quaternion.inl" diff --git a/external/include/glm/gtx/dual_quaternion.inl b/external/include/glm/gtx/dual_quaternion.inl new file mode 100644 index 0000000..c3f2bc6 --- /dev/null +++ b/external/include/glm/gtx/dual_quaternion.inl @@ -0,0 +1,351 @@ +/// @ref gtx_dual_quaternion +/// @file glm/gtx/dual_quaternion.inl + +#include "../geometric.hpp" +#include + +namespace glm +{ + // -- Component accesses -- + + template + GLM_FUNC_QUALIFIER typename tdualquat::part_type & tdualquat::operator[](typename tdualquat::length_type i) + { + assert(i >= 0 && i < this->length()); + return (&real)[i]; + } + + template + GLM_FUNC_QUALIFIER typename tdualquat::part_type const & tdualquat::operator[](typename tdualquat::length_type i) const + { + assert(i >= 0 && i < this->length()); + return (&real)[i]; + } + + // -- Implicit basic constructors -- + +# if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT) + template + GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat() +# ifndef GLM_FORCE_NO_CTOR_INIT + : real(tquat()) + , dual(tquat(0, 0, 0, 0)) +# endif + {} +# endif + +# if !GLM_HAS_DEFAULTED_FUNCTIONS + template + GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(tdualquat const & d) + : real(d.real) + , dual(d.dual) + {} +# endif//!GLM_HAS_DEFAULTED_FUNCTIONS + + template + template + GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(tdualquat const & d) + : real(d.real) + , dual(d.dual) + {} + + // -- Explicit basic constructors -- + + template + GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR tdualquat::tdualquat(ctor) + {} + + template + GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(tquat const & r) + : real(r), dual(tquat(0, 0, 0, 0)) + {} + + template + GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(tquat const & q, tvec3 const& p) + : real(q), dual( + T(-0.5) * ( p.x*q.x + p.y*q.y + p.z*q.z), + T(+0.5) * ( p.x*q.w + p.y*q.z - p.z*q.y), + T(+0.5) * (-p.x*q.z + p.y*q.w + p.z*q.x), + T(+0.5) * ( p.x*q.y - p.y*q.x + p.z*q.w)) + {} + + template + GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(tquat const & r, tquat const & d) + : real(r), dual(d) + {} + + // -- Conversion constructors -- + + template + template + GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(tdualquat const & q) + : real(q.real) + , dual(q.dual) + {} + + template + GLM_FUNC_QUALIFIER tdualquat::tdualquat(tmat2x4 const & m) + { + *this = dualquat_cast(m); + } + + template + GLM_FUNC_QUALIFIER tdualquat::tdualquat(tmat3x4 const & m) + { + *this = dualquat_cast(m); + } + + // -- Unary arithmetic operators -- + +# if !GLM_HAS_DEFAULTED_FUNCTIONS + template + GLM_FUNC_QUALIFIER tdualquat & tdualquat::operator=(tdualquat const & q) + { + this->real = q.real; + this->dual = q.dual; + return *this; + } +# endif//!GLM_HAS_DEFAULTED_FUNCTIONS + + template + template + GLM_FUNC_QUALIFIER tdualquat & tdualquat::operator=(tdualquat const & q) + { + this->real = q.real; + this->dual = q.dual; + return *this; + } + + template + template + GLM_FUNC_QUALIFIER tdualquat & tdualquat::operator*=(U s) + { + this->real *= static_cast(s); + this->dual *= static_cast(s); + return *this; + } + + template + template + GLM_FUNC_QUALIFIER tdualquat & tdualquat::operator/=(U s) + { + this->real /= static_cast(s); + this->dual /= static_cast(s); + return *this; + } + + // -- Unary bit operators -- + + template + GLM_FUNC_QUALIFIER tdualquat operator+(tdualquat const & q) + { + return q; + } + + template + GLM_FUNC_QUALIFIER tdualquat operator-(tdualquat const & q) + { + return tdualquat(-q.real, -q.dual); + } + + // -- Binary operators -- + + template + GLM_FUNC_QUALIFIER tdualquat operator+(tdualquat const & q, tdualquat const & p) + { + return tdualquat(q.real + p.real,q.dual + p.dual); + } + + template + GLM_FUNC_QUALIFIER tdualquat operator*(tdualquat const & p, tdualquat const & o) + { + return tdualquat(p.real * o.real,p.real * o.dual + p.dual * o.real); + } + + template + GLM_FUNC_QUALIFIER tvec3 operator*(tdualquat const & q, tvec3 const & v) + { + tvec3 const real_v3(q.real.x,q.real.y,q.real.z); + tvec3 const dual_v3(q.dual.x,q.dual.y,q.dual.z); + return (cross(real_v3, cross(real_v3,v) + v * q.real.w + dual_v3) + dual_v3 * q.real.w - real_v3 * q.dual.w) * T(2) + v; + } + + template + GLM_FUNC_QUALIFIER tvec3 operator*(tvec3 const & v, tdualquat const & q) + { + return glm::inverse(q) * v; + } + + template + GLM_FUNC_QUALIFIER tvec4 operator*(tdualquat const & q, tvec4 const & v) + { + return tvec4(q * tvec3(v), v.w); + } + + template + GLM_FUNC_QUALIFIER tvec4 operator*(tvec4 const & v, tdualquat const & q) + { + return glm::inverse(q) * v; + } + + template + GLM_FUNC_QUALIFIER tdualquat operator*(tdualquat const & q, T const & s) + { + return tdualquat(q.real * s, q.dual * s); + } + + template + GLM_FUNC_QUALIFIER tdualquat operator*(T const & s, tdualquat const & q) + { + return q * s; + } + + template + GLM_FUNC_QUALIFIER tdualquat operator/(tdualquat const & q, T const & s) + { + return tdualquat(q.real / s, q.dual / s); + } + + // -- Boolean operators -- + + template + GLM_FUNC_QUALIFIER bool operator==(tdualquat const & q1, tdualquat const & q2) + { + return (q1.real == q2.real) && (q1.dual == q2.dual); + } + + template + GLM_FUNC_QUALIFIER bool operator!=(tdualquat const & q1, tdualquat const & q2) + { + return (q1.real != q2.dual) || (q1.real != q2.dual); + } + + // -- Operations -- + + template + GLM_FUNC_QUALIFIER tdualquat normalize(tdualquat const & q) + { + return q / length(q.real); + } + + template + GLM_FUNC_QUALIFIER tdualquat lerp(tdualquat const & x, tdualquat const & y, T const & a) + { + // Dual Quaternion Linear blend aka DLB: + // Lerp is only defined in [0, 1] + assert(a >= static_cast(0)); + assert(a <= static_cast(1)); + T const k = dot(x.real,y.real) < static_cast(0) ? -a : a; + T const one(1); + return tdualquat(x * (one - a) + y * k); + } + + template + GLM_FUNC_QUALIFIER tdualquat inverse(tdualquat const & q) + { + const glm::tquat real = conjugate(q.real); + const glm::tquat dual = conjugate(q.dual); + return tdualquat(real, dual + (real * (-2.0f * dot(real,dual)))); + } + + template + GLM_FUNC_QUALIFIER tmat2x4 mat2x4_cast(tdualquat const & x) + { + return tmat2x4( x[0].x, x[0].y, x[0].z, x[0].w, x[1].x, x[1].y, x[1].z, x[1].w ); + } + + template + GLM_FUNC_QUALIFIER tmat3x4 mat3x4_cast(tdualquat const & x) + { + tquat r = x.real / length2(x.real); + + tquat const rr(r.w * x.real.w, r.x * x.real.x, r.y * x.real.y, r.z * x.real.z); + r *= static_cast(2); + + T const xy = r.x * x.real.y; + T const xz = r.x * x.real.z; + T const yz = r.y * x.real.z; + T const wx = r.w * x.real.x; + T const wy = r.w * x.real.y; + T const wz = r.w * x.real.z; + + tvec4 const a( + rr.w + rr.x - rr.y - rr.z, + xy - wz, + xz + wy, + -(x.dual.w * r.x - x.dual.x * r.w + x.dual.y * r.z - x.dual.z * r.y)); + + tvec4 const b( + xy + wz, + rr.w + rr.y - rr.x - rr.z, + yz - wx, + -(x.dual.w * r.y - x.dual.x * r.z - x.dual.y * r.w + x.dual.z * r.x)); + + tvec4 const c( + xz - wy, + yz + wx, + rr.w + rr.z - rr.x - rr.y, + -(x.dual.w * r.z + x.dual.x * r.y - x.dual.y * r.x - x.dual.z * r.w)); + + return tmat3x4(a, b, c); + } + + template + GLM_FUNC_QUALIFIER tdualquat dualquat_cast(tmat2x4 const & x) + { + return tdualquat( + tquat( x[0].w, x[0].x, x[0].y, x[0].z ), + tquat( x[1].w, x[1].x, x[1].y, x[1].z )); + } + + template + GLM_FUNC_QUALIFIER tdualquat dualquat_cast(tmat3x4 const & x) + { + tquat real(uninitialize); + + T const trace = x[0].x + x[1].y + x[2].z; + if(trace > static_cast(0)) + { + T const r = sqrt(T(1) + trace); + T const invr = static_cast(0.5) / r; + real.w = static_cast(0.5) * r; + real.x = (x[2].y - x[1].z) * invr; + real.y = (x[0].z - x[2].x) * invr; + real.z = (x[1].x - x[0].y) * invr; + } + else if(x[0].x > x[1].y && x[0].x > x[2].z) + { + T const r = sqrt(T(1) + x[0].x - x[1].y - x[2].z); + T const invr = static_cast(0.5) / r; + real.x = static_cast(0.5)*r; + real.y = (x[1].x + x[0].y) * invr; + real.z = (x[0].z + x[2].x) * invr; + real.w = (x[2].y - x[1].z) * invr; + } + else if(x[1].y > x[2].z) + { + T const r = sqrt(T(1) + x[1].y - x[0].x - x[2].z); + T const invr = static_cast(0.5) / r; + real.x = (x[1].x + x[0].y) * invr; + real.y = static_cast(0.5) * r; + real.z = (x[2].y + x[1].z) * invr; + real.w = (x[0].z - x[2].x) * invr; + } + else + { + T const r = sqrt(T(1) + x[2].z - x[0].x - x[1].y); + T const invr = static_cast(0.5) / r; + real.x = (x[0].z + x[2].x) * invr; + real.y = (x[2].y + x[1].z) * invr; + real.z = static_cast(0.5) * r; + real.w = (x[1].x - x[0].y) * invr; + } + + tquat dual(uninitialize); + dual.x = static_cast(0.5) * ( x[0].w * real.w + x[1].w * real.z - x[2].w * real.y); + dual.y = static_cast(0.5) * (-x[0].w * real.z + x[1].w * real.w + x[2].w * real.x); + dual.z = static_cast(0.5) * ( x[0].w * real.y - x[1].w * real.x + x[2].w * real.w); + dual.w = -static_cast(0.5) * ( x[0].w * real.x + x[1].w * real.y + x[2].w * real.z); + return tdualquat(real, dual); + } +}//namespace glm diff --git a/external/include/glm/gtx/euler_angles.hpp b/external/include/glm/gtx/euler_angles.hpp new file mode 100644 index 0000000..fdc4f26 --- /dev/null +++ b/external/include/glm/gtx/euler_angles.hpp @@ -0,0 +1,143 @@ +/// @ref gtx_euler_angles +/// @file glm/gtx/euler_angles.hpp +/// +/// @see core (dependence) +/// @see gtc_half_float (dependence) +/// +/// @defgroup gtx_euler_angles GLM_GTX_euler_angles +/// @ingroup gtx +/// +/// @brief Build matrices from Euler angles. +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../glm.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_euler_angles extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_euler_angles + /// @{ + + /// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X. + /// @see gtx_euler_angles + template + GLM_FUNC_DECL tmat4x4 eulerAngleX( + T const & angleX); + + /// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Y. + /// @see gtx_euler_angles + template + GLM_FUNC_DECL tmat4x4 eulerAngleY( + T const & angleY); + + /// Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Z. + /// @see gtx_euler_angles + template + GLM_FUNC_DECL tmat4x4 eulerAngleZ( + T const & angleZ); + + /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y). + /// @see gtx_euler_angles + template + GLM_FUNC_DECL tmat4x4 eulerAngleXY( + T const & angleX, + T const & angleY); + + /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X). + /// @see gtx_euler_angles + template + GLM_FUNC_DECL tmat4x4 eulerAngleYX( + T const & angleY, + T const & angleX); + + /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z). + /// @see gtx_euler_angles + template + GLM_FUNC_DECL tmat4x4 eulerAngleXZ( + T const & angleX, + T const & angleZ); + + /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X). + /// @see gtx_euler_angles + template + GLM_FUNC_DECL tmat4x4 eulerAngleZX( + T const & angle, + T const & angleX); + + /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z). + /// @see gtx_euler_angles + template + GLM_FUNC_DECL tmat4x4 eulerAngleYZ( + T const & angleY, + T const & angleZ); + + /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y). + /// @see gtx_euler_angles + template + GLM_FUNC_DECL tmat4x4 eulerAngleZY( + T const & angleZ, + T const & angleY); + + /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y * Z). + /// @see gtx_euler_angles + template + GLM_FUNC_DECL tmat4x4 eulerAngleXYZ( + T const & t1, + T const & t2, + T const & t3); + + /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z). + /// @see gtx_euler_angles + template + GLM_FUNC_DECL tmat4x4 eulerAngleYXZ( + T const & yaw, + T const & pitch, + T const & roll); + + /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z). + /// @see gtx_euler_angles + template + GLM_FUNC_DECL tmat4x4 yawPitchRoll( + T const & yaw, + T const & pitch, + T const & roll); + + /// Creates a 2D 2 * 2 rotation matrix from an euler angle. + /// @see gtx_euler_angles + template + GLM_FUNC_DECL tmat2x2 orientate2(T const & angle); + + /// Creates a 2D 4 * 4 homogeneous rotation matrix from an euler angle. + /// @see gtx_euler_angles + template + GLM_FUNC_DECL tmat3x3 orientate3(T const & angle); + + /// Creates a 3D 3 * 3 rotation matrix from euler angles (Y * X * Z). + /// @see gtx_euler_angles + template + GLM_FUNC_DECL tmat3x3 orientate3(tvec3 const & angles); + + /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z). + /// @see gtx_euler_angles + template + GLM_FUNC_DECL tmat4x4 orientate4(tvec3 const & angles); + + /// Extracts the (X * Y * Z) Euler angles from the rotation matrix M + /// @see gtx_euler_angles + template + GLM_FUNC_DECL void extractEulerAngleXYZ(tmat4x4 const & M, + T & t1, + T & t2, + T & t3); + + /// @} +}//namespace glm + +#include "euler_angles.inl" diff --git a/external/include/glm/gtx/euler_angles.inl b/external/include/glm/gtx/euler_angles.inl new file mode 100644 index 0000000..dbe0a48 --- /dev/null +++ b/external/include/glm/gtx/euler_angles.inl @@ -0,0 +1,312 @@ +/// @ref gtx_euler_angles +/// @file glm/gtx/euler_angles.inl + +#include "compatibility.hpp" // glm::atan2 + +namespace glm +{ + template + GLM_FUNC_QUALIFIER tmat4x4 eulerAngleX + ( + T const & angleX + ) + { + T cosX = glm::cos(angleX); + T sinX = glm::sin(angleX); + + return tmat4x4( + T(1), T(0), T(0), T(0), + T(0), cosX, sinX, T(0), + T(0),-sinX, cosX, T(0), + T(0), T(0), T(0), T(1)); + } + + template + GLM_FUNC_QUALIFIER tmat4x4 eulerAngleY + ( + T const & angleY + ) + { + T cosY = glm::cos(angleY); + T sinY = glm::sin(angleY); + + return tmat4x4( + cosY, T(0), -sinY, T(0), + T(0), T(1), T(0), T(0), + sinY, T(0), cosY, T(0), + T(0), T(0), T(0), T(1)); + } + + template + GLM_FUNC_QUALIFIER tmat4x4 eulerAngleZ + ( + T const & angleZ + ) + { + T cosZ = glm::cos(angleZ); + T sinZ = glm::sin(angleZ); + + return tmat4x4( + cosZ, sinZ, T(0), T(0), + -sinZ, cosZ, T(0), T(0), + T(0), T(0), T(1), T(0), + T(0), T(0), T(0), T(1)); + } + + template + GLM_FUNC_QUALIFIER tmat4x4 eulerAngleXY + ( + T const & angleX, + T const & angleY + ) + { + T cosX = glm::cos(angleX); + T sinX = glm::sin(angleX); + T cosY = glm::cos(angleY); + T sinY = glm::sin(angleY); + + return tmat4x4( + cosY, -sinX * -sinY, cosX * -sinY, T(0), + T(0), cosX, sinX, T(0), + sinY, -sinX * cosY, cosX * cosY, T(0), + T(0), T(0), T(0), T(1)); + } + + template + GLM_FUNC_QUALIFIER tmat4x4 eulerAngleYX + ( + T const & angleY, + T const & angleX + ) + { + T cosX = glm::cos(angleX); + T sinX = glm::sin(angleX); + T cosY = glm::cos(angleY); + T sinY = glm::sin(angleY); + + return tmat4x4( + cosY, 0, -sinY, T(0), + sinY * sinX, cosX, cosY * sinX, T(0), + sinY * cosX, -sinX, cosY * cosX, T(0), + T(0), T(0), T(0), T(1)); + } + + template + GLM_FUNC_QUALIFIER tmat4x4 eulerAngleXZ + ( + T const & angleX, + T const & angleZ + ) + { + return eulerAngleX(angleX) * eulerAngleZ(angleZ); + } + + template + GLM_FUNC_QUALIFIER tmat4x4 eulerAngleZX + ( + T const & angleZ, + T const & angleX + ) + { + return eulerAngleZ(angleZ) * eulerAngleX(angleX); + } + + template + GLM_FUNC_QUALIFIER tmat4x4 eulerAngleYZ + ( + T const & angleY, + T const & angleZ + ) + { + return eulerAngleY(angleY) * eulerAngleZ(angleZ); + } + + template + GLM_FUNC_QUALIFIER tmat4x4 eulerAngleZY + ( + T const & angleZ, + T const & angleY + ) + { + return eulerAngleZ(angleZ) * eulerAngleY(angleY); + } + + template + GLM_FUNC_QUALIFIER tmat4x4 eulerAngleXYZ + ( + T const & t1, + T const & t2, + T const & t3 + ) + { + T c1 = glm::cos(-t1); + T c2 = glm::cos(-t2); + T c3 = glm::cos(-t3); + T s1 = glm::sin(-t1); + T s2 = glm::sin(-t2); + T s3 = glm::sin(-t3); + + tmat4x4 Result; + Result[0][0] = c2 * c3; + Result[0][1] =-c1 * s3 + s1 * s2 * c3; + Result[0][2] = s1 * s3 + c1 * s2 * c3; + Result[0][3] = static_cast(0); + Result[1][0] = c2 * s3; + Result[1][1] = c1 * c3 + s1 * s2 * s3; + Result[1][2] =-s1 * c3 + c1 * s2 * s3; + Result[1][3] = static_cast(0); + Result[2][0] =-s2; + Result[2][1] = s1 * c2; + Result[2][2] = c1 * c2; + Result[2][3] = static_cast(0); + Result[3][0] = static_cast(0); + Result[3][1] = static_cast(0); + Result[3][2] = static_cast(0); + Result[3][3] = static_cast(1); + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat4x4 eulerAngleYXZ + ( + T const & yaw, + T const & pitch, + T const & roll + ) + { + T tmp_ch = glm::cos(yaw); + T tmp_sh = glm::sin(yaw); + T tmp_cp = glm::cos(pitch); + T tmp_sp = glm::sin(pitch); + T tmp_cb = glm::cos(roll); + T tmp_sb = glm::sin(roll); + + tmat4x4 Result; + Result[0][0] = tmp_ch * tmp_cb + tmp_sh * tmp_sp * tmp_sb; + Result[0][1] = tmp_sb * tmp_cp; + Result[0][2] = -tmp_sh * tmp_cb + tmp_ch * tmp_sp * tmp_sb; + Result[0][3] = static_cast(0); + Result[1][0] = -tmp_ch * tmp_sb + tmp_sh * tmp_sp * tmp_cb; + Result[1][1] = tmp_cb * tmp_cp; + Result[1][2] = tmp_sb * tmp_sh + tmp_ch * tmp_sp * tmp_cb; + Result[1][3] = static_cast(0); + Result[2][0] = tmp_sh * tmp_cp; + Result[2][1] = -tmp_sp; + Result[2][2] = tmp_ch * tmp_cp; + Result[2][3] = static_cast(0); + Result[3][0] = static_cast(0); + Result[3][1] = static_cast(0); + Result[3][2] = static_cast(0); + Result[3][3] = static_cast(1); + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat4x4 yawPitchRoll + ( + T const & yaw, + T const & pitch, + T const & roll + ) + { + T tmp_ch = glm::cos(yaw); + T tmp_sh = glm::sin(yaw); + T tmp_cp = glm::cos(pitch); + T tmp_sp = glm::sin(pitch); + T tmp_cb = glm::cos(roll); + T tmp_sb = glm::sin(roll); + + tmat4x4 Result; + Result[0][0] = tmp_ch * tmp_cb + tmp_sh * tmp_sp * tmp_sb; + Result[0][1] = tmp_sb * tmp_cp; + Result[0][2] = -tmp_sh * tmp_cb + tmp_ch * tmp_sp * tmp_sb; + Result[0][3] = static_cast(0); + Result[1][0] = -tmp_ch * tmp_sb + tmp_sh * tmp_sp * tmp_cb; + Result[1][1] = tmp_cb * tmp_cp; + Result[1][2] = tmp_sb * tmp_sh + tmp_ch * tmp_sp * tmp_cb; + Result[1][3] = static_cast(0); + Result[2][0] = tmp_sh * tmp_cp; + Result[2][1] = -tmp_sp; + Result[2][2] = tmp_ch * tmp_cp; + Result[2][3] = static_cast(0); + Result[3][0] = static_cast(0); + Result[3][1] = static_cast(0); + Result[3][2] = static_cast(0); + Result[3][3] = static_cast(1); + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat2x2 orientate2 + ( + T const & angle + ) + { + T c = glm::cos(angle); + T s = glm::sin(angle); + + tmat2x2 Result; + Result[0][0] = c; + Result[0][1] = s; + Result[1][0] = -s; + Result[1][1] = c; + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat3x3 orientate3 + ( + T const & angle + ) + { + T c = glm::cos(angle); + T s = glm::sin(angle); + + tmat3x3 Result; + Result[0][0] = c; + Result[0][1] = s; + Result[0][2] = 0.0f; + Result[1][0] = -s; + Result[1][1] = c; + Result[1][2] = 0.0f; + Result[2][0] = 0.0f; + Result[2][1] = 0.0f; + Result[2][2] = 1.0f; + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat3x3 orientate3 + ( + tvec3 const & angles + ) + { + return tmat3x3(yawPitchRoll(angles.z, angles.x, angles.y)); + } + + template + GLM_FUNC_QUALIFIER tmat4x4 orientate4 + ( + tvec3 const & angles + ) + { + return yawPitchRoll(angles.z, angles.x, angles.y); + } + + template + GLM_FUNC_DECL void extractEulerAngleXYZ(tmat4x4 const & M, + T & t1, + T & t2, + T & t3) + { + float T1 = glm::atan2(M[2][1], M[2][2]); + float C2 = glm::sqrt(M[0][0]*M[0][0] + M[1][0]*M[1][0]); + float T2 = glm::atan2(-M[2][0], C2); + float S1 = glm::sin(T1); + float C1 = glm::cos(T1); + float T3 = glm::atan2(S1*M[0][2] - C1*M[0][1], C1*M[1][1] - S1*M[1][2 ]); + t1 = -T1; + t2 = -T2; + t3 = -T3; + } +}//namespace glm diff --git a/external/include/glm/gtx/extend.hpp b/external/include/glm/gtx/extend.hpp new file mode 100644 index 0000000..26837a8 --- /dev/null +++ b/external/include/glm/gtx/extend.hpp @@ -0,0 +1,38 @@ +/// @ref gtx_extend +/// @file glm/gtx/extend.hpp +/// +/// @see core (dependence) +/// +/// @defgroup gtx_extend GLM_GTX_extend +/// @ingroup gtx +/// +/// @brief Extend a position from a source to a position at a defined length. +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../glm.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_extend extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_extend + /// @{ + + /// Extends of Length the Origin position using the (Source - Origin) direction. + /// @see gtx_extend + template + GLM_FUNC_DECL genType extend( + genType const & Origin, + genType const & Source, + typename genType::value_type const Length); + + /// @} +}//namespace glm + +#include "extend.inl" diff --git a/external/include/glm/gtx/extend.inl b/external/include/glm/gtx/extend.inl new file mode 100644 index 0000000..3155583 --- /dev/null +++ b/external/include/glm/gtx/extend.inl @@ -0,0 +1,49 @@ +/// @ref gtx_extend +/// @file glm/gtx/extend.inl + +namespace glm +{ + template + GLM_FUNC_QUALIFIER genType extend + ( + genType const & Origin, + genType const & Source, + genType const & Distance + ) + { + return Origin + (Source - Origin) * Distance; + } + + template + GLM_FUNC_QUALIFIER tvec2 extend + ( + tvec2 const & Origin, + tvec2 const & Source, + T const & Distance + ) + { + return Origin + (Source - Origin) * Distance; + } + + template + GLM_FUNC_QUALIFIER tvec3 extend + ( + tvec3 const & Origin, + tvec3 const & Source, + T const & Distance + ) + { + return Origin + (Source - Origin) * Distance; + } + + template + GLM_FUNC_QUALIFIER tvec4 extend + ( + tvec4 const & Origin, + tvec4 const & Source, + T const & Distance + ) + { + return Origin + (Source - Origin) * Distance; + } +}//namespace glm diff --git a/external/include/glm/gtx/extended_min_max.hpp b/external/include/glm/gtx/extended_min_max.hpp new file mode 100644 index 0000000..f4d8859 --- /dev/null +++ b/external/include/glm/gtx/extended_min_max.hpp @@ -0,0 +1,133 @@ +/// @ref gtx_extended_min_max +/// @file glm/gtx/extended_min_max.hpp +/// +/// @see core (dependence) +/// @see gtx_half_float (dependence) +/// +/// @defgroup gtx_extented_min_max GLM_GTX_extented_min_max +/// @ingroup gtx +/// +/// Min and max functions for 3 to 4 parameters. +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../glm.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_extented_min_max extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_extented_min_max + /// @{ + + /// Return the minimum component-wise values of 3 inputs + /// @see gtx_extented_min_max + template + GLM_FUNC_DECL T min( + T const & x, + T const & y, + T const & z); + + /// Return the minimum component-wise values of 3 inputs + /// @see gtx_extented_min_max + template class C> + GLM_FUNC_DECL C min( + C const & x, + typename C::T const & y, + typename C::T const & z); + + /// Return the minimum component-wise values of 3 inputs + /// @see gtx_extented_min_max + template class C> + GLM_FUNC_DECL C min( + C const & x, + C const & y, + C const & z); + + /// Return the minimum component-wise values of 4 inputs + /// @see gtx_extented_min_max + template + GLM_FUNC_DECL T min( + T const & x, + T const & y, + T const & z, + T const & w); + + /// Return the minimum component-wise values of 4 inputs + /// @see gtx_extented_min_max + template class C> + GLM_FUNC_DECL C min( + C const & x, + typename C::T const & y, + typename C::T const & z, + typename C::T const & w); + + /// Return the minimum component-wise values of 4 inputs + /// @see gtx_extented_min_max + template class C> + GLM_FUNC_DECL C min( + C const & x, + C const & y, + C const & z, + C const & w); + + /// Return the maximum component-wise values of 3 inputs + /// @see gtx_extented_min_max + template + GLM_FUNC_DECL T max( + T const & x, + T const & y, + T const & z); + + /// Return the maximum component-wise values of 3 inputs + /// @see gtx_extented_min_max + template class C> + GLM_FUNC_DECL C max( + C const & x, + typename C::T const & y, + typename C::T const & z); + + /// Return the maximum component-wise values of 3 inputs + /// @see gtx_extented_min_max + template class C> + GLM_FUNC_DECL C max( + C const & x, + C const & y, + C const & z); + + /// Return the maximum component-wise values of 4 inputs + /// @see gtx_extented_min_max + template + GLM_FUNC_DECL T max( + T const & x, + T const & y, + T const & z, + T const & w); + + /// Return the maximum component-wise values of 4 inputs + /// @see gtx_extented_min_max + template class C> + GLM_FUNC_DECL C max( + C const & x, + typename C::T const & y, + typename C::T const & z, + typename C::T const & w); + + /// Return the maximum component-wise values of 4 inputs + /// @see gtx_extented_min_max + template class C> + GLM_FUNC_DECL C max( + C const & x, + C const & y, + C const & z, + C const & w); + + /// @} +}//namespace glm + +#include "extended_min_max.inl" diff --git a/external/include/glm/gtx/extended_min_max.inl b/external/include/glm/gtx/extended_min_max.inl new file mode 100644 index 0000000..64ea445 --- /dev/null +++ b/external/include/glm/gtx/extended_min_max.inl @@ -0,0 +1,140 @@ +/// @ref gtx_extended_min_max +/// @file glm/gtx/extended_min_max.inl + +namespace glm +{ + template + GLM_FUNC_QUALIFIER T min( + T const & x, + T const & y, + T const & z) + { + return glm::min(glm::min(x, y), z); + } + + template class C> + GLM_FUNC_QUALIFIER C min + ( + C const & x, + typename C::T const & y, + typename C::T const & z + ) + { + return glm::min(glm::min(x, y), z); + } + + template class C> + GLM_FUNC_QUALIFIER C min + ( + C const & x, + C const & y, + C const & z + ) + { + return glm::min(glm::min(x, y), z); + } + + template + GLM_FUNC_QUALIFIER T min + ( + T const & x, + T const & y, + T const & z, + T const & w + ) + { + return glm::min(glm::min(x, y), glm::min(z, w)); + } + + template class C> + GLM_FUNC_QUALIFIER C min + ( + C const & x, + typename C::T const & y, + typename C::T const & z, + typename C::T const & w + ) + { + return glm::min(glm::min(x, y), glm::min(z, w)); + } + + template class C> + GLM_FUNC_QUALIFIER C min + ( + C const & x, + C const & y, + C const & z, + C const & w + ) + { + return glm::min(glm::min(x, y), glm::min(z, w)); + } + + template + GLM_FUNC_QUALIFIER T max( + T const & x, + T const & y, + T const & z) + { + return glm::max(glm::max(x, y), z); + } + + template class C> + GLM_FUNC_QUALIFIER C max + ( + C const & x, + typename C::T const & y, + typename C::T const & z + ) + { + return glm::max(glm::max(x, y), z); + } + + template class C> + GLM_FUNC_QUALIFIER C max + ( + C const & x, + C const & y, + C const & z + ) + { + return glm::max(glm::max(x, y), z); + } + + template + GLM_FUNC_QUALIFIER T max + ( + T const & x, + T const & y, + T const & z, + T const & w + ) + { + return glm::max(glm::max(x, y), glm::max(z, w)); + } + + template class C> + GLM_FUNC_QUALIFIER C max + ( + C const & x, + typename C::T const & y, + typename C::T const & z, + typename C::T const & w + ) + { + return glm::max(glm::max(x, y), glm::max(z, w)); + } + + template class C> + GLM_FUNC_QUALIFIER C max + ( + C const & x, + C const & y, + C const & z, + C const & w + ) + { + return glm::max(glm::max(x, y), glm::max(z, w)); + } + +}//namespace glm diff --git a/external/include/glm/gtx/fast_exponential.hpp b/external/include/glm/gtx/fast_exponential.hpp new file mode 100644 index 0000000..ed64a27 --- /dev/null +++ b/external/include/glm/gtx/fast_exponential.hpp @@ -0,0 +1,91 @@ +/// @ref gtx_fast_exponential +/// @file glm/gtx/fast_exponential.hpp +/// +/// @see core (dependence) +/// @see gtx_half_float (dependence) +/// +/// @defgroup gtx_fast_exponential GLM_GTX_fast_exponential +/// @ingroup gtx +/// +/// @brief Fast but less accurate implementations of exponential based functions. +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../glm.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_fast_exponential extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_fast_exponential + /// @{ + + /// Faster than the common pow function but less accurate. + /// @see gtx_fast_exponential + template + GLM_FUNC_DECL genType fastPow(genType x, genType y); + + /// Faster than the common pow function but less accurate. + /// @see gtx_fast_exponential + template class vecType> + GLM_FUNC_DECL vecType fastPow(vecType const & x, vecType const & y); + + /// Faster than the common pow function but less accurate. + /// @see gtx_fast_exponential + template + GLM_FUNC_DECL genTypeT fastPow(genTypeT x, genTypeU y); + + /// Faster than the common pow function but less accurate. + /// @see gtx_fast_exponential + template class vecType> + GLM_FUNC_DECL vecType fastPow(vecType const & x); + + /// Faster than the common exp function but less accurate. + /// @see gtx_fast_exponential + template + GLM_FUNC_DECL T fastExp(T x); + + /// Faster than the common exp function but less accurate. + /// @see gtx_fast_exponential + template class vecType> + GLM_FUNC_DECL vecType fastExp(vecType const & x); + + /// Faster than the common log function but less accurate. + /// @see gtx_fast_exponential + template + GLM_FUNC_DECL T fastLog(T x); + + /// Faster than the common exp2 function but less accurate. + /// @see gtx_fast_exponential + template class vecType> + GLM_FUNC_DECL vecType fastLog(vecType const & x); + + /// Faster than the common exp2 function but less accurate. + /// @see gtx_fast_exponential + template + GLM_FUNC_DECL T fastExp2(T x); + + /// Faster than the common exp2 function but less accurate. + /// @see gtx_fast_exponential + template class vecType> + GLM_FUNC_DECL vecType fastExp2(vecType const & x); + + /// Faster than the common log2 function but less accurate. + /// @see gtx_fast_exponential + template + GLM_FUNC_DECL T fastLog2(T x); + + /// Faster than the common log2 function but less accurate. + /// @see gtx_fast_exponential + template class vecType> + GLM_FUNC_DECL vecType fastLog2(vecType const & x); + + /// @} +}//namespace glm + +#include "fast_exponential.inl" diff --git a/external/include/glm/gtx/fast_exponential.inl b/external/include/glm/gtx/fast_exponential.inl new file mode 100644 index 0000000..72f9f8f --- /dev/null +++ b/external/include/glm/gtx/fast_exponential.inl @@ -0,0 +1,137 @@ +/// @ref gtx_fast_exponential +/// @file glm/gtx/fast_exponential.inl + +namespace glm +{ + // fastPow: + template + GLM_FUNC_QUALIFIER genType fastPow(genType x, genType y) + { + return exp(y * log(x)); + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType fastPow(vecType const & x, vecType const & y) + { + return exp(y * log(x)); + } + + template + GLM_FUNC_QUALIFIER T fastPow(T x, int y) + { + T f = static_cast(1); + for(int i = 0; i < y; ++i) + f *= x; + return f; + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType fastPow(vecType const & x, vecType const & y) + { + vecType Result(uninitialize); + for(length_t i = 0, n = x.length(); i < n; ++i) + Result[i] = fastPow(x[i], y[i]); + return Result; + } + + // fastExp + // Note: This function provides accurate results only for value between -1 and 1, else avoid it. + template + GLM_FUNC_QUALIFIER T fastExp(T x) + { + // This has a better looking and same performance in release mode than the following code. However, in debug mode it's slower. + // return 1.0f + x * (1.0f + x * 0.5f * (1.0f + x * 0.3333333333f * (1.0f + x * 0.25 * (1.0f + x * 0.2f)))); + T x2 = x * x; + T x3 = x2 * x; + T x4 = x3 * x; + T x5 = x4 * x; + return T(1) + x + (x2 * T(0.5)) + (x3 * T(0.1666666667)) + (x4 * T(0.041666667)) + (x5 * T(0.008333333333)); + } + /* // Try to handle all values of float... but often shower than std::exp, glm::floor and the loop kill the performance + GLM_FUNC_QUALIFIER float fastExp(float x) + { + const float e = 2.718281828f; + const float IntegerPart = floor(x); + const float FloatPart = x - IntegerPart; + float z = 1.f; + + for(int i = 0; i < int(IntegerPart); ++i) + z *= e; + + const float x2 = FloatPart * FloatPart; + const float x3 = x2 * FloatPart; + const float x4 = x3 * FloatPart; + const float x5 = x4 * FloatPart; + return z * (1.0f + FloatPart + (x2 * 0.5f) + (x3 * 0.1666666667f) + (x4 * 0.041666667f) + (x5 * 0.008333333333f)); + } + + // Increase accuracy on number bigger that 1 and smaller than -1 but it's not enough for high and negative numbers + GLM_FUNC_QUALIFIER float fastExp(float x) + { + // This has a better looking and same performance in release mode than the following code. However, in debug mode it's slower. + // return 1.0f + x * (1.0f + x * 0.5f * (1.0f + x * 0.3333333333f * (1.0f + x * 0.25 * (1.0f + x * 0.2f)))); + float x2 = x * x; + float x3 = x2 * x; + float x4 = x3 * x; + float x5 = x4 * x; + float x6 = x5 * x; + float x7 = x6 * x; + float x8 = x7 * x; + return 1.0f + x + (x2 * 0.5f) + (x3 * 0.1666666667f) + (x4 * 0.041666667f) + (x5 * 0.008333333333f)+ (x6 * 0.00138888888888f) + (x7 * 0.000198412698f) + (x8 * 0.0000248015873f);; + } + */ + + template class vecType> + GLM_FUNC_QUALIFIER vecType fastExp(vecType const & x) + { + return detail::functor1::call(fastExp, x); + } + + // fastLog + template + GLM_FUNC_QUALIFIER genType fastLog(genType x) + { + return std::log(x); + } + + /* Slower than the VC7.1 function... + GLM_FUNC_QUALIFIER float fastLog(float x) + { + float y1 = (x - 1.0f) / (x + 1.0f); + float y2 = y1 * y1; + return 2.0f * y1 * (1.0f + y2 * (0.3333333333f + y2 * (0.2f + y2 * 0.1428571429f))); + } + */ + + template class vecType> + GLM_FUNC_QUALIFIER vecType fastLog(vecType const & x) + { + return detail::functor1::call(fastLog, x); + } + + //fastExp2, ln2 = 0.69314718055994530941723212145818f + template + GLM_FUNC_QUALIFIER genType fastExp2(genType x) + { + return fastExp(0.69314718055994530941723212145818f * x); + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType fastExp2(vecType const & x) + { + return detail::functor1::call(fastExp2, x); + } + + // fastLog2, ln2 = 0.69314718055994530941723212145818f + template + GLM_FUNC_QUALIFIER genType fastLog2(genType x) + { + return fastLog(x) / 0.69314718055994530941723212145818f; + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType fastLog2(vecType const & x) + { + return detail::functor1::call(fastLog2, x); + } +}//namespace glm diff --git a/external/include/glm/gtx/fast_square_root.hpp b/external/include/glm/gtx/fast_square_root.hpp new file mode 100644 index 0000000..35aa7f3 --- /dev/null +++ b/external/include/glm/gtx/fast_square_root.hpp @@ -0,0 +1,88 @@ +/// @ref gtx_fast_square_root +/// @file glm/gtx/fast_square_root.hpp +/// +/// @see core (dependence) +/// +/// @defgroup gtx_fast_square_root GLM_GTX_fast_square_root +/// @ingroup gtx +/// +/// @brief Fast but less accurate implementations of square root based functions. +/// - Sqrt optimisation based on Newton's method, +/// www.gamedev.net/community/forums/topic.asp?topic id=139956 +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../common.hpp" +#include "../exponential.hpp" +#include "../geometric.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_fast_square_root extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_fast_square_root + /// @{ + + /// Faster than the common sqrt function but less accurate. + /// + /// @see gtx_fast_square_root extension. + template + GLM_FUNC_DECL genType fastSqrt(genType x); + + /// Faster than the common sqrt function but less accurate. + /// + /// @see gtx_fast_square_root extension. + template class vecType> + GLM_FUNC_DECL vecType fastSqrt(vecType const & x); + + /// Faster than the common inversesqrt function but less accurate. + /// + /// @see gtx_fast_square_root extension. + template + GLM_FUNC_DECL genType fastInverseSqrt(genType x); + + /// Faster than the common inversesqrt function but less accurate. + /// + /// @see gtx_fast_square_root extension. + template class vecType> + GLM_FUNC_DECL vecType fastInverseSqrt(vecType const & x); + + /// Faster than the common length function but less accurate. + /// + /// @see gtx_fast_square_root extension. + template + GLM_FUNC_DECL genType fastLength(genType x); + + /// Faster than the common length function but less accurate. + /// + /// @see gtx_fast_square_root extension. + template class vecType> + GLM_FUNC_DECL T fastLength(vecType const & x); + + /// Faster than the common distance function but less accurate. + /// + /// @see gtx_fast_square_root extension. + template + GLM_FUNC_DECL genType fastDistance(genType x, genType y); + + /// Faster than the common distance function but less accurate. + /// + /// @see gtx_fast_square_root extension. + template class vecType> + GLM_FUNC_DECL T fastDistance(vecType const & x, vecType const & y); + + /// Faster than the common normalize function but less accurate. + /// + /// @see gtx_fast_square_root extension. + template + GLM_FUNC_DECL genType fastNormalize(genType const & x); + + /// @} +}// namespace glm + +#include "fast_square_root.inl" diff --git a/external/include/glm/gtx/fast_square_root.inl b/external/include/glm/gtx/fast_square_root.inl new file mode 100644 index 0000000..73950ae --- /dev/null +++ b/external/include/glm/gtx/fast_square_root.inl @@ -0,0 +1,81 @@ +/// @ref gtx_fast_square_root +/// @file glm/gtx/fast_square_root.inl + +namespace glm +{ + // fastSqrt + template + GLM_FUNC_QUALIFIER genType fastSqrt(genType x) + { + GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fastSqrt' only accept floating-point input"); + + return genType(1) / fastInverseSqrt(x); + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType fastSqrt(vecType const & x) + { + return detail::functor1::call(fastSqrt, x); + } + + // fastInversesqrt + template + GLM_FUNC_QUALIFIER genType fastInverseSqrt(genType x) + { +# ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6 + tvec1 tmp(detail::compute_inversesqrt::value>::call(tvec1(x))); + return tmp.x; +# else + return detail::compute_inversesqrt::value>::call(tvec1(x)).x; +# endif + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType fastInverseSqrt(vecType const & x) + { + return detail::compute_inversesqrt::value>::call(x); + } + + // fastLength + template + GLM_FUNC_QUALIFIER genType fastLength(genType x) + { + GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fastLength' only accept floating-point inputs"); + + return abs(x); + } + + template class vecType> + GLM_FUNC_QUALIFIER T fastLength(vecType const & x) + { + GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fastLength' only accept floating-point inputs"); + + return fastSqrt(dot(x, x)); + } + + // fastDistance + template + GLM_FUNC_QUALIFIER genType fastDistance(genType x, genType y) + { + return fastLength(y - x); + } + + template class vecType> + GLM_FUNC_QUALIFIER T fastDistance(vecType const & x, vecType const & y) + { + return fastLength(y - x); + } + + // fastNormalize + template + GLM_FUNC_QUALIFIER genType fastNormalize(genType x) + { + return x > genType(0) ? genType(1) : -genType(1); + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType fastNormalize(vecType const & x) + { + return x * fastInverseSqrt(dot(x, x)); + } +}//namespace glm diff --git a/external/include/glm/gtx/fast_trigonometry.hpp b/external/include/glm/gtx/fast_trigonometry.hpp new file mode 100644 index 0000000..ccb1d22 --- /dev/null +++ b/external/include/glm/gtx/fast_trigonometry.hpp @@ -0,0 +1,75 @@ +/// @ref gtx_fast_trigonometry +/// @file glm/gtx/fast_trigonometry.hpp +/// +/// @see core (dependence) +/// +/// @defgroup gtx_fast_trigonometry GLM_GTX_fast_trigonometry +/// @ingroup gtx +/// +/// @brief Fast but less accurate implementations of trigonometric functions. +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../gtc/constants.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_fast_trigonometry extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_fast_trigonometry + /// @{ + + /// Wrap an angle to [0 2pi[ + /// From GLM_GTX_fast_trigonometry extension. + template + GLM_FUNC_DECL T wrapAngle(T angle); + + /// Faster than the common sin function but less accurate. + /// From GLM_GTX_fast_trigonometry extension. + template + GLM_FUNC_DECL T fastSin(T angle); + + /// Faster than the common cos function but less accurate. + /// From GLM_GTX_fast_trigonometry extension. + template + GLM_FUNC_DECL T fastCos(T angle); + + /// Faster than the common tan function but less accurate. + /// Defined between -2pi and 2pi. + /// From GLM_GTX_fast_trigonometry extension. + template + GLM_FUNC_DECL T fastTan(T angle); + + /// Faster than the common asin function but less accurate. + /// Defined between -2pi and 2pi. + /// From GLM_GTX_fast_trigonometry extension. + template + GLM_FUNC_DECL T fastAsin(T angle); + + /// Faster than the common acos function but less accurate. + /// Defined between -2pi and 2pi. + /// From GLM_GTX_fast_trigonometry extension. + template + GLM_FUNC_DECL T fastAcos(T angle); + + /// Faster than the common atan function but less accurate. + /// Defined between -2pi and 2pi. + /// From GLM_GTX_fast_trigonometry extension. + template + GLM_FUNC_DECL T fastAtan(T y, T x); + + /// Faster than the common atan function but less accurate. + /// Defined between -2pi and 2pi. + /// From GLM_GTX_fast_trigonometry extension. + template + GLM_FUNC_DECL T fastAtan(T angle); + + /// @} +}//namespace glm + +#include "fast_trigonometry.inl" diff --git a/external/include/glm/gtx/fast_trigonometry.inl b/external/include/glm/gtx/fast_trigonometry.inl new file mode 100644 index 0000000..f576c17 --- /dev/null +++ b/external/include/glm/gtx/fast_trigonometry.inl @@ -0,0 +1,143 @@ +/// @ref gtx_fast_trigonometry +/// @file glm/gtx/fast_trigonometry.inl + +namespace glm{ +namespace detail +{ + template class vecType> + GLM_FUNC_QUALIFIER vecType taylorCos(vecType const & x) + { + return static_cast(1) + - (x * x) / 2.f + + (x * x * x * x) / 24.f + - (x * x * x * x * x * x) / 720.f + + (x * x * x * x * x * x * x * x) / 40320.f; + } + + template + GLM_FUNC_QUALIFIER T cos_52s(T x) + { + T const xx(x * x); + return (T(0.9999932946) + xx * (T(-0.4999124376) + xx * (T(0.0414877472) + xx * T(-0.0012712095)))); + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType cos_52s(vecType const & x) + { + return detail::functor1::call(cos_52s, x); + } +}//namespace detail + + // wrapAngle + template + GLM_FUNC_QUALIFIER T wrapAngle(T angle) + { + return abs(mod(angle, two_pi())); + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType wrapAngle(vecType const & x) + { + return detail::functor1::call(wrapAngle, x); + } + + // cos + template + GLM_FUNC_QUALIFIER T fastCos(T x) + { + T const angle(wrapAngle(x)); + + if(angle < half_pi()) + return detail::cos_52s(angle); + if(angle < pi()) + return -detail::cos_52s(pi() - angle); + if(angle < (T(3) * half_pi())) + return -detail::cos_52s(angle - pi()); + + return detail::cos_52s(two_pi() - angle); + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType fastCos(vecType const & x) + { + return detail::functor1::call(fastCos, x); + } + + // sin + template + GLM_FUNC_QUALIFIER T fastSin(T x) + { + return fastCos(half_pi() - x); + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType fastSin(vecType const & x) + { + return detail::functor1::call(fastSin, x); + } + + // tan + template + GLM_FUNC_QUALIFIER T fastTan(T x) + { + return x + (x * x * x * T(0.3333333333)) + (x * x * x * x * x * T(0.1333333333333)) + (x * x * x * x * x * x * x * T(0.0539682539)); + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType fastTan(vecType const & x) + { + return detail::functor1::call(fastTan, x); + } + + // asin + template + GLM_FUNC_QUALIFIER T fastAsin(T x) + { + return x + (x * x * x * T(0.166666667)) + (x * x * x * x * x * T(0.075)) + (x * x * x * x * x * x * x * T(0.0446428571)) + (x * x * x * x * x * x * x * x * x * T(0.0303819444));// + (x * x * x * x * x * x * x * x * x * x * x * T(0.022372159)); + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType fastAsin(vecType const & x) + { + return detail::functor1::call(fastAsin, x); + } + + // acos + template + GLM_FUNC_QUALIFIER T fastAcos(T x) + { + return T(1.5707963267948966192313216916398) - fastAsin(x); //(PI / 2) + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType fastAcos(vecType const & x) + { + return detail::functor1::call(fastAcos, x); + } + + // atan + template + GLM_FUNC_QUALIFIER T fastAtan(T y, T x) + { + T sgn = sign(y) * sign(x); + return abs(fastAtan(y / x)) * sgn; + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType fastAtan(vecType const & y, vecType const & x) + { + return detail::functor2::call(fastAtan, y, x); + } + + template + GLM_FUNC_QUALIFIER T fastAtan(T x) + { + return x - (x * x * x * T(0.333333333333)) + (x * x * x * x * x * T(0.2)) - (x * x * x * x * x * x * x * T(0.1428571429)) + (x * x * x * x * x * x * x * x * x * T(0.111111111111)) - (x * x * x * x * x * x * x * x * x * x * x * T(0.0909090909)); + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType fastAtan(vecType const & x) + { + return detail::functor1::call(fastAtan, x); + } +}//namespace glm diff --git a/external/include/glm/gtx/float_notmalize.inl b/external/include/glm/gtx/float_notmalize.inl new file mode 100644 index 0000000..4dde025 --- /dev/null +++ b/external/include/glm/gtx/float_notmalize.inl @@ -0,0 +1,14 @@ +/// @ref gtx_float_normalize +/// @file glm/gtx/float_normalize.inl + +#include + +namespace glm +{ + template class vecType> + GLM_FUNC_QUALIFIER vecType floatNormalize(vecType const & v) + { + return vecType(v) / static_cast(std::numeric_limits::max()); + } + +}//namespace glm diff --git a/external/include/glm/gtx/gradient_paint.hpp b/external/include/glm/gtx/gradient_paint.hpp new file mode 100644 index 0000000..de1f18d --- /dev/null +++ b/external/include/glm/gtx/gradient_paint.hpp @@ -0,0 +1,48 @@ +/// @ref gtx_gradient_paint +/// @file glm/gtx/gradient_paint.hpp +/// +/// @see core (dependence) +/// @see gtx_optimum_pow (dependence) +/// +/// @defgroup gtx_gradient_paint GLM_GTX_gradient_paint +/// @ingroup gtx +/// +/// @brief Functions that return the color of procedural gradient for specific coordinates. +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../glm.hpp" +#include "../gtx/optimum_pow.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_gradient_paint extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_gradient_paint + /// @{ + + /// Return a color from a radial gradient. + /// @see - gtx_gradient_paint + template + GLM_FUNC_DECL T radialGradient( + tvec2 const & Center, + T const & Radius, + tvec2 const & Focal, + tvec2 const & Position); + + /// Return a color from a linear gradient. + /// @see - gtx_gradient_paint + template + GLM_FUNC_DECL T linearGradient( + tvec2 const & Point0, + tvec2 const & Point1, + tvec2 const & Position); + + /// @} +}// namespace glm + +#include "gradient_paint.inl" diff --git a/external/include/glm/gtx/gradient_paint.inl b/external/include/glm/gtx/gradient_paint.inl new file mode 100644 index 0000000..aaa5ce1 --- /dev/null +++ b/external/include/glm/gtx/gradient_paint.inl @@ -0,0 +1,37 @@ +/// @ref gtx_gradient_paint +/// @file glm/gtx/gradient_paint.inl + +namespace glm +{ + template + GLM_FUNC_QUALIFIER T radialGradient + ( + tvec2 const & Center, + T const & Radius, + tvec2 const & Focal, + tvec2 const & Position + ) + { + tvec2 F = Focal - Center; + tvec2 D = Position - Focal; + T Radius2 = pow2(Radius); + T Fx2 = pow2(F.x); + T Fy2 = pow2(F.y); + + 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)); + T Denominator = Radius2 - (Fx2 + Fy2); + return Numerator / Denominator; + } + + template + GLM_FUNC_QUALIFIER T linearGradient + ( + tvec2 const & Point0, + tvec2 const & Point1, + tvec2 const & Position + ) + { + tvec2 Dist = Point1 - Point0; + return (Dist.x * (Position.x - Point0.x) + Dist.y * (Position.y - Point0.y)) / glm::dot(Dist, Dist); + } +}//namespace glm diff --git a/external/include/glm/gtx/handed_coordinate_space.hpp b/external/include/glm/gtx/handed_coordinate_space.hpp new file mode 100644 index 0000000..2ee5175 --- /dev/null +++ b/external/include/glm/gtx/handed_coordinate_space.hpp @@ -0,0 +1,46 @@ +/// @ref gtx_handed_coordinate_space +/// @file glm/gtx/handed_coordinate_space.hpp +/// +/// @see core (dependence) +/// +/// @defgroup gtx_handed_coordinate_space GLM_GTX_handed_coordinate_space +/// @ingroup gtx +/// +/// @brief To know if a set of three basis vectors defines a right or left-handed coordinate system. +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../glm.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_handed_coordinate_space extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_handed_coordinate_space + /// @{ + + //! Return if a trihedron right handed or not. + //! From GLM_GTX_handed_coordinate_space extension. + template + GLM_FUNC_DECL bool rightHanded( + tvec3 const & tangent, + tvec3 const & binormal, + tvec3 const & normal); + + //! Return if a trihedron left handed or not. + //! From GLM_GTX_handed_coordinate_space extension. + template + GLM_FUNC_DECL bool leftHanded( + tvec3 const & tangent, + tvec3 const & binormal, + tvec3 const & normal); + + /// @} +}// namespace glm + +#include "handed_coordinate_space.inl" diff --git a/external/include/glm/gtx/handed_coordinate_space.inl b/external/include/glm/gtx/handed_coordinate_space.inl new file mode 100644 index 0000000..2e55653 --- /dev/null +++ b/external/include/glm/gtx/handed_coordinate_space.inl @@ -0,0 +1,27 @@ +/// @ref gtx_handed_coordinate_space +/// @file glm/gtx/handed_coordinate_space.inl + +namespace glm +{ + template + GLM_FUNC_QUALIFIER bool rightHanded + ( + tvec3 const & tangent, + tvec3 const & binormal, + tvec3 const & normal + ) + { + return dot(cross(normal, tangent), binormal) > T(0); + } + + template + GLM_FUNC_QUALIFIER bool leftHanded + ( + tvec3 const & tangent, + tvec3 const & binormal, + tvec3 const & normal + ) + { + return dot(cross(normal, tangent), binormal) < T(0); + } +}//namespace glm diff --git a/external/include/glm/gtx/hash.hpp b/external/include/glm/gtx/hash.hpp new file mode 100644 index 0000000..2262618 --- /dev/null +++ b/external/include/glm/gtx/hash.hpp @@ -0,0 +1,134 @@ +/// @ref gtx_hash +/// @file glm/gtx/hash.hpp +/// +/// @see core (dependence) +/// +/// @defgroup gtx_hash GLM_GTX_hash +/// @ingroup gtx +/// +/// @brief Add std::hash support for glm types +/// +/// need to be included to use these functionalities. + +#pragma once + +#include + +#include "../vec2.hpp" +#include "../vec3.hpp" +#include "../vec4.hpp" +#include "../gtc/vec1.hpp" + +#include "../gtc/quaternion.hpp" +#include "../gtx/dual_quaternion.hpp" + +#include "../mat2x2.hpp" +#include "../mat2x3.hpp" +#include "../mat2x4.hpp" + +#include "../mat3x2.hpp" +#include "../mat3x3.hpp" +#include "../mat3x4.hpp" + +#include "../mat4x2.hpp" +#include "../mat4x3.hpp" +#include "../mat4x4.hpp" + +#if !GLM_HAS_CXX11_STL +# error "GLM_GTX_hash requires C++11 standard library support" +#endif + +namespace std +{ + template + struct hash > + { + GLM_FUNC_DECL size_t operator()(glm::tvec1 const & v) const; + }; + + template + struct hash > + { + GLM_FUNC_DECL size_t operator()(glm::tvec2 const & v) const; + }; + + template + struct hash > + { + GLM_FUNC_DECL size_t operator()(glm::tvec3 const & v) const; + }; + + template + struct hash > + { + GLM_FUNC_DECL size_t operator()(glm::tvec4 const & v) const; + }; + + template + struct hash> + { + GLM_FUNC_DECL size_t operator()(glm::tquat const & q) const; + }; + + template + struct hash > + { + GLM_FUNC_DECL size_t operator()(glm::tdualquat const & q) const; + }; + + template + struct hash > + { + GLM_FUNC_DECL size_t operator()(glm::tmat2x2 const & m) const; + }; + + template + struct hash > + { + GLM_FUNC_DECL size_t operator()(glm::tmat2x3 const & m) const; + }; + + template + struct hash > + { + GLM_FUNC_DECL size_t operator()(glm::tmat2x4 const & m) const; + }; + + template + struct hash > + { + GLM_FUNC_DECL size_t operator()(glm::tmat3x2 const & m) const; + }; + + template + struct hash > + { + GLM_FUNC_DECL size_t operator()(glm::tmat3x3 const & m) const; + }; + + template + struct hash > + { + GLM_FUNC_DECL size_t operator()(glm::tmat3x4 const & m) const; + }; + + template + struct hash > + { + GLM_FUNC_DECL size_t operator()(glm::tmat4x2 const & m) const; + }; + + template + struct hash > + { + GLM_FUNC_DECL size_t operator()(glm::tmat4x3 const & m) const; + }; + + template + struct hash > + { + GLM_FUNC_DECL size_t operator()(glm::tmat4x4 const & m) const; + }; +} // namespace std + +#include "hash.inl" diff --git a/external/include/glm/gtx/hash.inl b/external/include/glm/gtx/hash.inl new file mode 100644 index 0000000..c42f4f0 --- /dev/null +++ b/external/include/glm/gtx/hash.inl @@ -0,0 +1,185 @@ +/// @ref gtx_hash +/// @file glm/gtx/hash.inl +/// +/// @see core (dependence) +/// +/// @defgroup gtx_hash GLM_GTX_hash +/// @ingroup gtx +/// +/// @brief Add std::hash support for glm types +/// +/// need to be included to use these functionalities. + +namespace glm { +namespace detail +{ + GLM_INLINE void hash_combine(size_t &seed, size_t hash) + { + hash += 0x9e3779b9 + (seed << 6) + (seed >> 2); + seed ^= hash; + } +}} + +namespace std +{ + template + GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::tvec1 const & v) const + { + hash hasher; + return hasher(v.x); + } + + template + GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::tvec2 const & v) const + { + size_t seed = 0; + hash hasher; + glm::detail::hash_combine(seed, hasher(v.x)); + glm::detail::hash_combine(seed, hasher(v.y)); + return seed; + } + + template + GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::tvec3 const & v) const + { + size_t seed = 0; + hash hasher; + glm::detail::hash_combine(seed, hasher(v.x)); + glm::detail::hash_combine(seed, hasher(v.y)); + glm::detail::hash_combine(seed, hasher(v.z)); + return seed; + } + + template + GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::tvec4 const & v) const + { + size_t seed = 0; + hash hasher; + glm::detail::hash_combine(seed, hasher(v.x)); + glm::detail::hash_combine(seed, hasher(v.y)); + glm::detail::hash_combine(seed, hasher(v.z)); + glm::detail::hash_combine(seed, hasher(v.w)); + return seed; + } + + template + GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::tquat const & q) const + { + size_t seed = 0; + hash hasher; + glm::detail::hash_combine(seed, hasher(q.x)); + glm::detail::hash_combine(seed, hasher(q.y)); + glm::detail::hash_combine(seed, hasher(q.z)); + glm::detail::hash_combine(seed, hasher(q.w)); + return seed; + } + + template + GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::tdualquat const & q) const + { + size_t seed = 0; + hash> hasher; + glm::detail::hash_combine(seed, hasher(q.real)); + glm::detail::hash_combine(seed, hasher(q.dual)); + return seed; + } + + template + GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::tmat2x2 const & m) const + { + size_t seed = 0; + hash> hasher; + glm::detail::hash_combine(seed, hasher(m[0])); + glm::detail::hash_combine(seed, hasher(m[1])); + return seed; + } + + template + GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::tmat2x3 const & m) const + { + size_t seed = 0; + hash> hasher; + glm::detail::hash_combine(seed, hasher(m[0])); + glm::detail::hash_combine(seed, hasher(m[1])); + return seed; + } + + template + GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::tmat2x4 const & m) const + { + size_t seed = 0; + hash> hasher; + glm::detail::hash_combine(seed, hasher(m[0])); + glm::detail::hash_combine(seed, hasher(m[1])); + return seed; + } + + template + GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::tmat3x2 const & m) const + { + size_t seed = 0; + hash> hasher; + glm::detail::hash_combine(seed, hasher(m[0])); + glm::detail::hash_combine(seed, hasher(m[1])); + glm::detail::hash_combine(seed, hasher(m[2])); + return seed; + } + + template + GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::tmat3x3 const & m) const + { + size_t seed = 0; + hash> hasher; + glm::detail::hash_combine(seed, hasher(m[0])); + glm::detail::hash_combine(seed, hasher(m[1])); + glm::detail::hash_combine(seed, hasher(m[2])); + return seed; + } + + template + GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::tmat3x4 const & m) const + { + size_t seed = 0; + hash> hasher; + glm::detail::hash_combine(seed, hasher(m[0])); + glm::detail::hash_combine(seed, hasher(m[1])); + glm::detail::hash_combine(seed, hasher(m[2])); + return seed; + } + + template + GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::tmat4x2 const & m) const + { + size_t seed = 0; + hash> hasher; + glm::detail::hash_combine(seed, hasher(m[0])); + glm::detail::hash_combine(seed, hasher(m[1])); + glm::detail::hash_combine(seed, hasher(m[2])); + glm::detail::hash_combine(seed, hasher(m[3])); + return seed; + } + + template + GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::tmat4x3 const & m) const + { + size_t seed = 0; + hash> hasher; + glm::detail::hash_combine(seed, hasher(m[0])); + glm::detail::hash_combine(seed, hasher(m[1])); + glm::detail::hash_combine(seed, hasher(m[2])); + glm::detail::hash_combine(seed, hasher(m[3])); + return seed; + } + + template + GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::tmat4x4 const & m) const + { + size_t seed = 0; + hash> hasher; + glm::detail::hash_combine(seed, hasher(m[0])); + glm::detail::hash_combine(seed, hasher(m[1])); + glm::detail::hash_combine(seed, hasher(m[2])); + glm::detail::hash_combine(seed, hasher(m[3])); + return seed; + } +} diff --git a/external/include/glm/gtx/integer.hpp b/external/include/glm/gtx/integer.hpp new file mode 100644 index 0000000..1173a58 --- /dev/null +++ b/external/include/glm/gtx/integer.hpp @@ -0,0 +1,72 @@ +/// @ref gtx_integer +/// @file glm/gtx/integer.hpp +/// +/// @see core (dependence) +/// +/// @defgroup gtx_integer GLM_GTX_integer +/// @ingroup gtx +/// +/// @brief Add support for integer for core functions +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../glm.hpp" +#include "../gtc/integer.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_integer extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_integer + /// @{ + + //! Returns x raised to the y power. + //! From GLM_GTX_integer extension. + GLM_FUNC_DECL int pow(int x, int y); + + //! Returns the positive square root of x. + //! From GLM_GTX_integer extension. + GLM_FUNC_DECL int sqrt(int x); + + //! Returns the floor log2 of x. + //! From GLM_GTX_integer extension. + GLM_FUNC_DECL unsigned int floor_log2(unsigned int x); + + //! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y. + //! From GLM_GTX_integer extension. + GLM_FUNC_DECL int mod(int x, int y); + + //! Return the factorial value of a number (!12 max, integer only) + //! From GLM_GTX_integer extension. + template + GLM_FUNC_DECL genType factorial(genType const & x); + + //! 32bit signed integer. + //! From GLM_GTX_integer extension. + typedef signed int sint; + + //! Returns x raised to the y power. + //! From GLM_GTX_integer extension. + GLM_FUNC_DECL uint pow(uint x, uint y); + + //! Returns the positive square root of x. + //! From GLM_GTX_integer extension. + GLM_FUNC_DECL uint sqrt(uint x); + + //! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y. + //! From GLM_GTX_integer extension. + GLM_FUNC_DECL uint mod(uint x, uint y); + + //! Returns the number of leading zeros. + //! From GLM_GTX_integer extension. + GLM_FUNC_DECL uint nlz(uint x); + + /// @} +}//namespace glm + +#include "integer.inl" diff --git a/external/include/glm/gtx/integer.inl b/external/include/glm/gtx/integer.inl new file mode 100644 index 0000000..3a479e6 --- /dev/null +++ b/external/include/glm/gtx/integer.inl @@ -0,0 +1,182 @@ +/// @ref gtx_integer +/// @file glm/gtx/integer.inl + +namespace glm +{ + // pow + GLM_FUNC_QUALIFIER int pow(int x, int y) + { + if(y == 0) + return 1; + int result = x; + for(int i = 1; i < y; ++i) + result *= x; + return result; + } + + // sqrt: From Christopher J. Musial, An integer square root, Graphics Gems, 1990, page 387 + GLM_FUNC_QUALIFIER int sqrt(int x) + { + if(x <= 1) return x; + + int NextTrial = x >> 1; + int CurrentAnswer; + + do + { + CurrentAnswer = NextTrial; + NextTrial = (NextTrial + x / NextTrial) >> 1; + } while(NextTrial < CurrentAnswer); + + return CurrentAnswer; + } + +// Henry Gordon Dietz: http://aggregate.org/MAGIC/ +namespace detail +{ + GLM_FUNC_QUALIFIER unsigned int ones32(unsigned int x) + { + /* 32-bit recursive reduction using SWAR... + but first step is mapping 2-bit values + into sum of 2 1-bit values in sneaky way + */ + x -= ((x >> 1) & 0x55555555); + x = (((x >> 2) & 0x33333333) + (x & 0x33333333)); + x = (((x >> 4) + x) & 0x0f0f0f0f); + x += (x >> 8); + x += (x >> 16); + return(x & 0x0000003f); + } +}//namespace detail + + // Henry Gordon Dietz: http://aggregate.org/MAGIC/ +/* + GLM_FUNC_QUALIFIER unsigned int floor_log2(unsigned int x) + { + x |= (x >> 1); + x |= (x >> 2); + x |= (x >> 4); + x |= (x >> 8); + x |= (x >> 16); + + return _detail::ones32(x) >> 1; + } +*/ + // mod + GLM_FUNC_QUALIFIER int mod(int x, int y) + { + return x - y * (x / y); + } + + // factorial (!12 max, integer only) + template + GLM_FUNC_QUALIFIER genType factorial(genType const & x) + { + genType Temp = x; + genType Result; + for(Result = 1; Temp > 1; --Temp) + Result *= Temp; + return Result; + } + + template + GLM_FUNC_QUALIFIER tvec2 factorial( + tvec2 const & x) + { + return tvec2( + factorial(x.x), + factorial(x.y)); + } + + template + GLM_FUNC_QUALIFIER tvec3 factorial( + tvec3 const & x) + { + return tvec3( + factorial(x.x), + factorial(x.y), + factorial(x.z)); + } + + template + GLM_FUNC_QUALIFIER tvec4 factorial( + tvec4 const & x) + { + return tvec4( + factorial(x.x), + factorial(x.y), + factorial(x.z), + factorial(x.w)); + } + + GLM_FUNC_QUALIFIER uint pow(uint x, uint y) + { + uint result = x; + for(uint i = 1; i < y; ++i) + result *= x; + return result; + } + + GLM_FUNC_QUALIFIER uint sqrt(uint x) + { + if(x <= 1) return x; + + uint NextTrial = x >> 1; + uint CurrentAnswer; + + do + { + CurrentAnswer = NextTrial; + NextTrial = (NextTrial + x / NextTrial) >> 1; + } while(NextTrial < CurrentAnswer); + + return CurrentAnswer; + } + + GLM_FUNC_QUALIFIER uint mod(uint x, uint y) + { + return x - y * (x / y); + } + +#if(GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_GCC)) + + GLM_FUNC_QUALIFIER unsigned int nlz(unsigned int x) + { + return 31u - findMSB(x); + } + +#else + + // Hackers Delight: http://www.hackersdelight.org/HDcode/nlz.c.txt + GLM_FUNC_QUALIFIER unsigned int nlz(unsigned int x) + { + int y, m, n; + + y = -int(x >> 16); // If left half of x is 0, + m = (y >> 16) & 16; // set n = 16. If left half + n = 16 - m; // is nonzero, set n = 0 and + x = x >> m; // shift x right 16. + // Now x is of the form 0000xxxx. + y = x - 0x100; // If positions 8-15 are 0, + m = (y >> 16) & 8; // add 8 to n and shift x left 8. + n = n + m; + x = x << m; + + y = x - 0x1000; // If positions 12-15 are 0, + m = (y >> 16) & 4; // add 4 to n and shift x left 4. + n = n + m; + x = x << m; + + y = x - 0x4000; // If positions 14-15 are 0, + m = (y >> 16) & 2; // add 2 to n and shift x left 2. + n = n + m; + x = x << m; + + y = x >> 14; // Set y = 0, 1, 2, or 3. + m = y & ~(y >> 1); // Set m = 0, 1, 2, or 2 resp. + return unsigned(n + 2 - m); + } + +#endif//(GLM_COMPILER) + +}//namespace glm diff --git a/external/include/glm/gtx/intersect.hpp b/external/include/glm/gtx/intersect.hpp new file mode 100644 index 0000000..33b6e99 --- /dev/null +++ b/external/include/glm/gtx/intersect.hpp @@ -0,0 +1,87 @@ +/// @ref gtx_intersect +/// @file glm/gtx/intersect.hpp +/// +/// @see core (dependence) +/// @see gtx_closest_point (dependence) +/// +/// @defgroup gtx_intersect GLM_GTX_intersect +/// @ingroup gtx +/// +/// @brief Add intersection functions +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include +#include +#include "../glm.hpp" +#include "../geometric.hpp" +#include "../gtx/closest_point.hpp" +#include "../gtx/vector_query.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_closest_point extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_intersect + /// @{ + + //! Compute the intersection of a ray and a plane. + //! Ray direction and plane normal must be unit length. + //! From GLM_GTX_intersect extension. + template + GLM_FUNC_DECL bool intersectRayPlane( + genType const & orig, genType const & dir, + genType const & planeOrig, genType const & planeNormal, + typename genType::value_type & intersectionDistance); + + //! Compute the intersection of a ray and a triangle. + //! From GLM_GTX_intersect extension. + template + GLM_FUNC_DECL bool intersectRayTriangle( + genType const & orig, genType const & dir, + genType const & vert0, genType const & vert1, genType const & vert2, + genType & baryPosition); + + //! Compute the intersection of a line and a triangle. + //! From GLM_GTX_intersect extension. + template + GLM_FUNC_DECL bool intersectLineTriangle( + genType const & orig, genType const & dir, + genType const & vert0, genType const & vert1, genType const & vert2, + genType & position); + + //! Compute the intersection distance of a ray and a sphere. + //! The ray direction vector is unit length. + //! From GLM_GTX_intersect extension. + template + GLM_FUNC_DECL bool intersectRaySphere( + genType const & rayStarting, genType const & rayNormalizedDirection, + genType const & sphereCenter, typename genType::value_type const sphereRadiusSquered, + typename genType::value_type & intersectionDistance); + + //! Compute the intersection of a ray and a sphere. + //! From GLM_GTX_intersect extension. + template + GLM_FUNC_DECL bool intersectRaySphere( + genType const & rayStarting, genType const & rayNormalizedDirection, + genType const & sphereCenter, const typename genType::value_type sphereRadius, + genType & intersectionPosition, genType & intersectionNormal); + + //! Compute the intersection of a line and a sphere. + //! From GLM_GTX_intersect extension + template + GLM_FUNC_DECL bool intersectLineSphere( + genType const & point0, genType const & point1, + genType const & sphereCenter, typename genType::value_type sphereRadius, + genType & intersectionPosition1, genType & intersectionNormal1, + genType & intersectionPosition2 = genType(), genType & intersectionNormal2 = genType()); + + /// @} +}//namespace glm + +#include "intersect.inl" diff --git a/external/include/glm/gtx/intersect.inl b/external/include/glm/gtx/intersect.inl new file mode 100644 index 0000000..904d6cc --- /dev/null +++ b/external/include/glm/gtx/intersect.inl @@ -0,0 +1,170 @@ +/// @ref gtx_intersect +/// @file glm/gtx/intersect.inl + +namespace glm +{ + template + GLM_FUNC_QUALIFIER bool intersectRayPlane + ( + genType const & orig, genType const & dir, + genType const & planeOrig, genType const & planeNormal, + typename genType::value_type & intersectionDistance + ) + { + typename genType::value_type d = glm::dot(dir, planeNormal); + typename genType::value_type Epsilon = std::numeric_limits::epsilon(); + + if(d < -Epsilon) + { + intersectionDistance = glm::dot(planeOrig - orig, planeNormal) / d; + return true; + } + + return false; + } + + template + GLM_FUNC_QUALIFIER bool intersectRayTriangle + ( + genType const & orig, genType const & dir, + genType const & v0, genType const & v1, genType const & v2, + genType & baryPosition + ) + { + genType e1 = v1 - v0; + genType e2 = v2 - v0; + + genType p = glm::cross(dir, e2); + + typename genType::value_type a = glm::dot(e1, p); + + typename genType::value_type Epsilon = std::numeric_limits::epsilon(); + if(a < Epsilon && a > -Epsilon) + return false; + + typename genType::value_type f = typename genType::value_type(1.0f) / a; + + genType s = orig - v0; + baryPosition.x = f * glm::dot(s, p); + if(baryPosition.x < typename genType::value_type(0.0f)) + return false; + if(baryPosition.x > typename genType::value_type(1.0f)) + return false; + + genType q = glm::cross(s, e1); + baryPosition.y = f * glm::dot(dir, q); + if(baryPosition.y < typename genType::value_type(0.0f)) + return false; + if(baryPosition.y + baryPosition.x > typename genType::value_type(1.0f)) + return false; + + baryPosition.z = f * glm::dot(e2, q); + + return baryPosition.z >= typename genType::value_type(0.0f); + } + + template + GLM_FUNC_QUALIFIER bool intersectLineTriangle + ( + genType const & orig, genType const & dir, + genType const & vert0, genType const & vert1, genType const & vert2, + genType & position + ) + { + typename genType::value_type Epsilon = std::numeric_limits::epsilon(); + + genType edge1 = vert1 - vert0; + genType edge2 = vert2 - vert0; + + genType pvec = cross(dir, edge2); + + float det = dot(edge1, pvec); + + if (det > -Epsilon && det < Epsilon) + return false; + float inv_det = typename genType::value_type(1) / det; + + genType tvec = orig - vert0; + + position.y = dot(tvec, pvec) * inv_det; + if (position.y < typename genType::value_type(0) || position.y > typename genType::value_type(1)) + return false; + + genType qvec = cross(tvec, edge1); + + position.z = dot(dir, qvec) * inv_det; + if (position.z < typename genType::value_type(0) || position.y + position.z > typename genType::value_type(1)) + return false; + + position.x = dot(edge2, qvec) * inv_det; + + return true; + } + + template + GLM_FUNC_QUALIFIER bool intersectRaySphere + ( + genType const & rayStarting, genType const & rayNormalizedDirection, + genType const & sphereCenter, const typename genType::value_type sphereRadiusSquered, + typename genType::value_type & intersectionDistance + ) + { + typename genType::value_type Epsilon = std::numeric_limits::epsilon(); + genType diff = sphereCenter - rayStarting; + typename genType::value_type t0 = dot(diff, rayNormalizedDirection); + typename genType::value_type dSquared = dot(diff, diff) - t0 * t0; + if( dSquared > sphereRadiusSquered ) + { + return false; + } + typename genType::value_type t1 = sqrt( sphereRadiusSquered - dSquared ); + intersectionDistance = t0 > t1 + Epsilon ? t0 - t1 : t0 + t1; + return intersectionDistance > Epsilon; + } + + template + GLM_FUNC_QUALIFIER bool intersectRaySphere + ( + genType const & rayStarting, genType const & rayNormalizedDirection, + genType const & sphereCenter, const typename genType::value_type sphereRadius, + genType & intersectionPosition, genType & intersectionNormal + ) + { + typename genType::value_type distance; + if( intersectRaySphere( rayStarting, rayNormalizedDirection, sphereCenter, sphereRadius * sphereRadius, distance ) ) + { + intersectionPosition = rayStarting + rayNormalizedDirection * distance; + intersectionNormal = (intersectionPosition - sphereCenter) / sphereRadius; + return true; + } + return false; + } + + template + GLM_FUNC_QUALIFIER bool intersectLineSphere + ( + genType const & point0, genType const & point1, + genType const & sphereCenter, typename genType::value_type sphereRadius, + genType & intersectionPoint1, genType & intersectionNormal1, + genType & intersectionPoint2, genType & intersectionNormal2 + ) + { + typename genType::value_type Epsilon = std::numeric_limits::epsilon(); + genType dir = normalize(point1 - point0); + genType diff = sphereCenter - point0; + typename genType::value_type t0 = dot(diff, dir); + typename genType::value_type dSquared = dot(diff, diff) - t0 * t0; + if( dSquared > sphereRadius * sphereRadius ) + { + return false; + } + typename genType::value_type t1 = sqrt( sphereRadius * sphereRadius - dSquared ); + if( t0 < t1 + Epsilon ) + t1 = -t1; + intersectionPoint1 = point0 + dir * (t0 - t1); + intersectionNormal1 = (intersectionPoint1 - sphereCenter) / sphereRadius; + intersectionPoint2 = point0 + dir * (t0 + t1); + intersectionNormal2 = (intersectionPoint2 - sphereCenter) / sphereRadius; + return true; + } +}//namespace glm diff --git a/external/include/glm/gtx/io.hpp b/external/include/glm/gtx/io.hpp new file mode 100644 index 0000000..6aa8415 --- /dev/null +++ b/external/include/glm/gtx/io.hpp @@ -0,0 +1,197 @@ +/// @ref gtx_io +/// @file glm/gtx/io.hpp +/// @author Jan P Springer (regnirpsj@gmail.com) +/// +/// @see core (dependence) +/// @see gtc_matrix_access (dependence) +/// @see gtc_quaternion (dependence) +/// +/// @defgroup gtx_io GLM_GTX_io +/// @ingroup gtx +/// +/// @brief std::[w]ostream support for glm types +/// +/// std::[w]ostream support for glm types + precision/width/etc. manipulators +/// based on howard hinnant's std::chrono io proposal +/// [http://home.roadrunner.com/~hinnant/bloomington/chrono_io.html] +/// +/// needs to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../glm.hpp" +#include "../gtx/quaternion.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_io extension included") +#endif + +#include // std::basic_ostream<> (fwd) +#include // std::locale, std::locale::facet, std::locale::id +#include // std::pair<> + +namespace glm +{ + /// @addtogroup gtx_io + /// @{ + + namespace io + { + enum order_type { column_major, row_major}; + + template + class format_punct : public std::locale::facet + { + typedef CTy char_type; + + public: + + static std::locale::id id; + + bool formatted; + unsigned precision; + unsigned width; + char_type separator; + char_type delim_left; + char_type delim_right; + char_type space; + char_type newline; + order_type order; + + GLM_FUNC_DECL explicit format_punct(size_t a = 0); + GLM_FUNC_DECL explicit format_punct(format_punct const&); + }; + + template > + class basic_state_saver { + + public: + + GLM_FUNC_DECL explicit basic_state_saver(std::basic_ios&); + GLM_FUNC_DECL ~basic_state_saver(); + + private: + + typedef ::std::basic_ios state_type; + typedef typename state_type::char_type char_type; + typedef ::std::ios_base::fmtflags flags_type; + typedef ::std::streamsize streamsize_type; + typedef ::std::locale const locale_type; + + state_type& state_; + flags_type flags_; + streamsize_type precision_; + streamsize_type width_; + char_type fill_; + locale_type locale_; + + GLM_FUNC_DECL basic_state_saver& operator=(basic_state_saver const&); + }; + + typedef basic_state_saver state_saver; + typedef basic_state_saver wstate_saver; + + template > + class basic_format_saver + { + public: + + GLM_FUNC_DECL explicit basic_format_saver(std::basic_ios&); + GLM_FUNC_DECL ~basic_format_saver(); + + private: + + basic_state_saver const bss_; + + GLM_FUNC_DECL basic_format_saver& operator=(basic_format_saver const&); + }; + + typedef basic_format_saver format_saver; + typedef basic_format_saver wformat_saver; + + struct precision + { + unsigned value; + + GLM_FUNC_DECL explicit precision(unsigned); + }; + + struct width + { + unsigned value; + + GLM_FUNC_DECL explicit width(unsigned); + }; + + template + struct delimeter + { + CTy value[3]; + + GLM_FUNC_DECL explicit delimeter(CTy /* left */, CTy /* right */, CTy /* separator */ = ','); + }; + + struct order + { + order_type value; + + GLM_FUNC_DECL explicit order(order_type); + }; + + // functions, inlined (inline) + + template + FTy const& get_facet(std::basic_ios&); + template + std::basic_ios& formatted(std::basic_ios&); + template + std::basic_ios& unformattet(std::basic_ios&); + + template + std::basic_ostream& operator<<(std::basic_ostream&, precision const&); + template + std::basic_ostream& operator<<(std::basic_ostream&, width const&); + template + std::basic_ostream& operator<<(std::basic_ostream&, delimeter const&); + template + std::basic_ostream& operator<<(std::basic_ostream&, order const&); + }//namespace io + + template + GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, tquat const&); + template + GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, tvec1 const&); + template + GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, tvec2 const&); + template + GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, tvec3 const&); + template + GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, tvec4 const&); + template + GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, tmat2x2 const&); + template + GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, tmat2x3 const&); + template + GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, tmat2x4 const&); + template + GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, tmat3x2 const&); + template + GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, tmat3x3 const&); + template + GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, tmat3x4 const&); + template + GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, tmat4x2 const&); + template + GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, tmat4x3 const&); + template + GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, tmat4x4 const&); + + template + GLM_FUNC_DECL std::basic_ostream & operator<<(std::basic_ostream &, + std::pair const, tmat4x4 const> const &); + + /// @} +}//namespace glm + +#include "io.inl" diff --git a/external/include/glm/gtx/io.inl b/external/include/glm/gtx/io.inl new file mode 100644 index 0000000..9b70a5f --- /dev/null +++ b/external/include/glm/gtx/io.inl @@ -0,0 +1,441 @@ +/// @ref gtx_io +/// @file glm/gtx/io.inl +/// @author Jan P Springer (regnirpsj@gmail.com) + +#include // std::fixed, std::setfill<>, std::setprecision, std::right, std::setw +#include // std::basic_ostream<> +#include "../gtc/matrix_access.hpp" // glm::col, glm::row +#include "../gtx/type_trait.hpp" // glm::type<> + +namespace glm{ +namespace io +{ + template + GLM_FUNC_QUALIFIER format_punct::format_punct(size_t a) + : std::locale::facet(a) + , formatted(true) + , precision(3) + , width(1 + 4 + 1 + precision) + , separator(',') + , delim_left('[') + , delim_right(']') + , space(' ') + , newline('\n') + , order(column_major) + {} + + template + GLM_FUNC_QUALIFIER format_punct::format_punct(format_punct const& a) + : std::locale::facet(0) + , formatted(a.formatted) + , precision(a.precision) + , width(a.width) + , separator(a.separator) + , delim_left(a.delim_left) + , delim_right(a.delim_right) + , space(a.space) + , newline(a.newline) + , order(a.order) + {} + + template std::locale::id format_punct::id; + + template + GLM_FUNC_QUALIFIER basic_state_saver::basic_state_saver(std::basic_ios& a) + : state_(a) + , flags_(a.flags()) + , precision_(a.precision()) + , width_(a.width()) + , fill_(a.fill()) + , locale_(a.getloc()) + {} + + template + GLM_FUNC_QUALIFIER basic_state_saver::~basic_state_saver() + { + state_.imbue(locale_); + state_.fill(fill_); + state_.width(width_); + state_.precision(precision_); + state_.flags(flags_); + } + + template + GLM_FUNC_QUALIFIER basic_format_saver::basic_format_saver(std::basic_ios& a) + : bss_(a) + { + a.imbue(std::locale(a.getloc(), new format_punct(get_facet >(a)))); + } + + template + GLM_FUNC_QUALIFIER + basic_format_saver::~basic_format_saver() + {} + + GLM_FUNC_QUALIFIER precision::precision(unsigned a) + : value(a) + {} + + GLM_FUNC_QUALIFIER width::width(unsigned a) + : value(a) + {} + + template + GLM_FUNC_QUALIFIER delimeter::delimeter(CTy a, CTy b, CTy c) + : value() + { + value[0] = a; + value[1] = b; + value[2] = c; + } + + GLM_FUNC_QUALIFIER order::order(order_type a) + : value(a) + {} + + template + GLM_FUNC_QUALIFIER FTy const& get_facet(std::basic_ios& ios) + { + if(!std::has_facet(ios.getloc())) + ios.imbue(std::locale(ios.getloc(), new FTy)); + + return std::use_facet(ios.getloc()); + } + + template + GLM_FUNC_QUALIFIER std::basic_ios& formatted(std::basic_ios& ios) + { + const_cast&>(get_facet >(ios)).formatted = true; + return ios; + } + + template + GLM_FUNC_QUALIFIER std::basic_ios& unformatted(std::basic_ios& ios) + { + const_cast&>(get_facet >(ios)).formatted = false; + return ios; + } + + template + GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, precision const& a) + { + const_cast&>(get_facet >(os)).precision = a.value; + return os; + } + + template + GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, width const& a) + { + const_cast&>(get_facet >(os)).width = a.value; + return os; + } + + template + GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, delimeter const& a) + { + format_punct & fmt(const_cast&>(get_facet >(os))); + + fmt.delim_left = a.value[0]; + fmt.delim_right = a.value[1]; + fmt.separator = a.value[2]; + + return os; + } + + template + GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, order const& a) + { + const_cast&>(get_facet >(os)).order = a.value; + return os; + } +} // namespace io + +namespace detail +{ + template class V, typename T, precision P> + GLM_FUNC_QUALIFIER std::basic_ostream& + print_vector_on(std::basic_ostream& os, V const& a) + { + typename std::basic_ostream::sentry const cerberus(os); + + if(cerberus) + { + io::format_punct const & fmt(io::get_facet >(os)); + + length_t const& components(type::components); + + if(fmt.formatted) + { + io::basic_state_saver const bss(os); + + os << std::fixed << std::right << std::setprecision(fmt.precision) << std::setfill(fmt.space) << fmt.delim_left; + + for(length_t i(0); i < components; ++i) + { + os << std::setw(fmt.width) << a[i]; + if(components-1 != i) + os << fmt.separator; + } + + os << fmt.delim_right; + } + else + { + for(length_t i(0); i < components; ++i) + { + os << a[i]; + + if(components-1 != i) + os << fmt.space; + } + } + } + + return os; + } +}//namespace detail + + template + GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, tquat const& a) + { + return detail::print_vector_on(os, a); + } + + template + GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, tvec1 const& a) + { + return detail::print_vector_on(os, a); + } + + template + GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, tvec2 const& a) + { + return detail::print_vector_on(os, a); + } + + template + GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, tvec3 const& a) + { + return detail::print_vector_on(os, a); + } + + template + GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, tvec4 const& a) + { + return detail::print_vector_on(os, a); + } + +namespace detail +{ + template class M, typename T, precision P> + GLM_FUNC_QUALIFIER std::basic_ostream& print_matrix_on(std::basic_ostream& os, M const& a) + { + typename std::basic_ostream::sentry const cerberus(os); + + if(cerberus) + { + io::format_punct const & fmt(io::get_facet >(os)); + + length_t const& cols(type::cols); + length_t const& rows(type::rows); + + if(fmt.formatted) + { + os << fmt.newline << fmt.delim_left; + + switch(fmt.order) + { + case io::column_major: + { + for(length_t i(0); i < rows; ++i) + { + if (0 != i) + os << fmt.space; + + os << row(a, i); + + if(rows-1 != i) + os << fmt.newline; + } + } + break; + + case io::row_major: + { + for(length_t i(0); i < cols; ++i) + { + if(0 != i) + os << fmt.space; + + os << column(a, i); + + if(cols-1 != i) + os << fmt.newline; + } + } + break; + } + + os << fmt.delim_right; + } + else + { + switch (fmt.order) + { + case io::column_major: + { + for(length_t i(0); i < cols; ++i) + { + os << column(a, i); + + if(cols - 1 != i) + os << fmt.space; + } + } + break; + + case io::row_major: + { + for (length_t i(0); i < rows; ++i) + { + os << row(a, i); + + if (rows-1 != i) + os << fmt.space; + } + } + break; + } + } + } + + return os; + } +}//namespace detail + + template + GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, tmat2x2 const& a) + { + return detail::print_matrix_on(os, a); + } + + template + GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, tmat2x3 const& a) + { + return detail::print_matrix_on(os, a); + } + + template + GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, tmat2x4 const& a) + { + return detail::print_matrix_on(os, a); + } + + template + GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, tmat3x2 const& a) + { + return detail::print_matrix_on(os, a); + } + + template + GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, tmat3x3 const& a) + { + return detail::print_matrix_on(os, a); + } + + template + GLM_FUNC_QUALIFIER std::basic_ostream & operator<<(std::basic_ostream& os, tmat3x4 const& a) + { + return detail::print_matrix_on(os, a); + } + + template + GLM_FUNC_QUALIFIER std::basic_ostream & operator<<(std::basic_ostream& os, tmat4x2 const& a) + { + return detail::print_matrix_on(os, a); + } + + template + GLM_FUNC_QUALIFIER std::basic_ostream & operator<<(std::basic_ostream& os, tmat4x3 const& a) + { + return detail::print_matrix_on(os, a); + } + + template + GLM_FUNC_QUALIFIER std::basic_ostream & operator<<(std::basic_ostream& os, tmat4x4 const& a) + { + return detail::print_matrix_on(os, a); + } + +namespace detail +{ + template class M, typename T, precision P> + GLM_FUNC_QUALIFIER std::basic_ostream& print_matrix_pair_on(std::basic_ostream& os, std::pair const, M const> const& a) + { + typename std::basic_ostream::sentry const cerberus(os); + + if(cerberus) + { + io::format_punct const& fmt(io::get_facet >(os)); + M const& ml(a.first); + M const& mr(a.second); + length_t const& cols(type::cols); + length_t const& rows(type::rows); + + if(fmt.formatted) + { + os << fmt.newline << fmt.delim_left; + + switch(fmt.order) + { + case io::column_major: + { + for(length_t i(0); i < rows; ++i) + { + if(0 != i) + os << fmt.space; + + os << row(ml, i) << ((rows-1 != i) ? fmt.space : fmt.delim_right) << fmt.space << ((0 != i) ? fmt.space : fmt.delim_left) << row(mr, i); + + if(rows-1 != i) + os << fmt.newline; + } + } + break; + case io::row_major: + { + for(length_t i(0); i < cols; ++i) + { + if(0 != i) + os << fmt.space; + + os << column(ml, i) << ((cols-1 != i) ? fmt.space : fmt.delim_right) << fmt.space << ((0 != i) ? fmt.space : fmt.delim_left) << column(mr, i); + + if(cols-1 != i) + os << fmt.newline; + } + } + break; + } + + os << fmt.delim_right; + } + else + { + os << ml << fmt.space << mr; + } + } + + return os; + } +}//namespace detail + + template + GLM_FUNC_QUALIFIER std::basic_ostream& operator<<( + std::basic_ostream & os, + std::pair const, + tmat4x4 const> const& a) + { + return detail::print_matrix_pair_on(os, a); + } +}//namespace glm diff --git a/external/include/glm/gtx/log_base.hpp b/external/include/glm/gtx/log_base.hpp new file mode 100644 index 0000000..7958fc3 --- /dev/null +++ b/external/include/glm/gtx/log_base.hpp @@ -0,0 +1,44 @@ +/// @ref gtx_log_base +/// @file glm/gtx/log_base.hpp +/// +/// @see core (dependence) +/// +/// @defgroup gtx_log_base GLM_GTX_log_base +/// @ingroup gtx +/// +/// @brief Logarithm for any base. base can be a vector or a scalar. +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../glm.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_log_base extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_log_base + /// @{ + + /// Logarithm for any base. + /// From GLM_GTX_log_base. + template + GLM_FUNC_DECL genType log( + genType const & x, + genType const & base); + + /// Logarithm for any base. + /// From GLM_GTX_log_base. + template class vecType> + GLM_FUNC_DECL vecType sign( + vecType const & x, + vecType const & base); + + /// @} +}//namespace glm + +#include "log_base.inl" diff --git a/external/include/glm/gtx/log_base.inl b/external/include/glm/gtx/log_base.inl new file mode 100644 index 0000000..8005d1b --- /dev/null +++ b/external/include/glm/gtx/log_base.inl @@ -0,0 +1,18 @@ +/// @ref gtx_log_base +/// @file glm/gtx/log_base.inl + +namespace glm +{ + template + GLM_FUNC_QUALIFIER genType log(genType const & x, genType const & base) + { + assert(x != genType(0)); + return glm::log(x) / glm::log(base); + } + + template class vecType> + GLM_FUNC_QUALIFIER vecType log(vecType const & x, vecType const & base) + { + return glm::log(x) / glm::log(base); + } +}//namespace glm diff --git a/external/include/glm/gtx/matrix_cross_product.hpp b/external/include/glm/gtx/matrix_cross_product.hpp new file mode 100644 index 0000000..d920f4e --- /dev/null +++ b/external/include/glm/gtx/matrix_cross_product.hpp @@ -0,0 +1,43 @@ +/// @ref gtx_matrix_cross_product +/// @file glm/gtx/matrix_cross_product.hpp +/// +/// @see core (dependence) +/// @see gtx_extented_min_max (dependence) +/// +/// @defgroup gtx_matrix_cross_product GLM_GTX_matrix_cross_product +/// @ingroup gtx +/// +/// @brief Build cross product matrices +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../glm.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_matrix_cross_product extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_matrix_cross_product + /// @{ + + //! Build a cross product matrix. + //! From GLM_GTX_matrix_cross_product extension. + template + GLM_FUNC_DECL tmat3x3 matrixCross3( + tvec3 const & x); + + //! Build a cross product matrix. + //! From GLM_GTX_matrix_cross_product extension. + template + GLM_FUNC_DECL tmat4x4 matrixCross4( + tvec3 const & x); + + /// @} +}//namespace glm + +#include "matrix_cross_product.inl" diff --git a/external/include/glm/gtx/matrix_cross_product.inl b/external/include/glm/gtx/matrix_cross_product.inl new file mode 100644 index 0000000..16f07e9 --- /dev/null +++ b/external/include/glm/gtx/matrix_cross_product.inl @@ -0,0 +1,38 @@ +/// @ref gtx_matrix_cross_product +/// @file glm/gtx/matrix_cross_product.inl + +namespace glm +{ + template + GLM_FUNC_QUALIFIER tmat3x3 matrixCross3 + ( + tvec3 const & x + ) + { + tmat3x3 Result(T(0)); + Result[0][1] = x.z; + Result[1][0] = -x.z; + Result[0][2] = -x.y; + Result[2][0] = x.y; + Result[1][2] = x.x; + Result[2][1] = -x.x; + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat4x4 matrixCross4 + ( + tvec3 const & x + ) + { + tmat4x4 Result(T(0)); + Result[0][1] = x.z; + Result[1][0] = -x.z; + Result[0][2] = -x.y; + Result[2][0] = x.y; + Result[1][2] = x.x; + Result[2][1] = -x.x; + return Result; + } + +}//namespace glm diff --git a/external/include/glm/gtx/matrix_decompose.hpp b/external/include/glm/gtx/matrix_decompose.hpp new file mode 100644 index 0000000..e163f5a --- /dev/null +++ b/external/include/glm/gtx/matrix_decompose.hpp @@ -0,0 +1,42 @@ +/// @ref gtx_matrix_decompose +/// @file glm/gtx/matrix_decompose.hpp +/// +/// @see core (dependence) +/// +/// @defgroup gtx_matrix_decompose GLM_GTX_matrix_decompose +/// @ingroup gtx +/// +/// @brief Decomposes a model matrix to translations, rotation and scale components +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependencies +#include "../mat4x4.hpp" +#include "../vec3.hpp" +#include "../vec4.hpp" +#include "../geometric.hpp" +#include "../gtc/quaternion.hpp" +#include "../gtc/matrix_transform.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_matrix_decompose extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_matrix_decompose + /// @{ + + /// Decomposes a model matrix to translations, rotation and scale components + /// @see gtx_matrix_decompose + template + GLM_FUNC_DECL bool decompose( + tmat4x4 const & modelMatrix, + tvec3 & scale, tquat & orientation, tvec3 & translation, tvec3 & skew, tvec4 & perspective); + + /// @} +}//namespace glm + +#include "matrix_decompose.inl" diff --git a/external/include/glm/gtx/matrix_decompose.inl b/external/include/glm/gtx/matrix_decompose.inl new file mode 100644 index 0000000..7194e9d --- /dev/null +++ b/external/include/glm/gtx/matrix_decompose.inl @@ -0,0 +1,194 @@ +/// @ref gtx_matrix_decompose +/// @file glm/gtx/matrix_decompose.inl + +namespace glm{ +namespace detail +{ + /// Make a linear combination of two vectors and return the result. + // result = (a * ascl) + (b * bscl) + template + GLM_FUNC_QUALIFIER tvec3 combine( + tvec3 const & a, + tvec3 const & b, + T ascl, T bscl) + { + return (a * ascl) + (b * bscl); + } + + template + GLM_FUNC_QUALIFIER tvec3 scale(tvec3 const& v, T desiredLength) + { + return v * desiredLength / length(v); + } +}//namespace detail + + // Matrix decompose + // http://www.opensource.apple.com/source/WebCore/WebCore-514/platform/graphics/transforms/TransformationMatrix.cpp + // Decomposes the mode matrix to translations,rotation scale components + + template + GLM_FUNC_QUALIFIER bool decompose(tmat4x4 const & ModelMatrix, tvec3 & Scale, tquat & Orientation, tvec3 & Translation, tvec3 & Skew, tvec4 & Perspective) + { + tmat4x4 LocalMatrix(ModelMatrix); + + // Normalize the matrix. + if(LocalMatrix[3][3] == static_cast(0)) + return false; + + for(length_t i = 0; i < 4; ++i) + for(length_t j = 0; j < 4; ++j) + LocalMatrix[i][j] /= LocalMatrix[3][3]; + + // perspectiveMatrix is used to solve for perspective, but it also provides + // an easy way to test for singularity of the upper 3x3 component. + tmat4x4 PerspectiveMatrix(LocalMatrix); + + for(length_t i = 0; i < 3; i++) + PerspectiveMatrix[i][3] = static_cast(0); + PerspectiveMatrix[3][3] = static_cast(1); + + /// TODO: Fixme! + if(determinant(PerspectiveMatrix) == static_cast(0)) + return false; + + // First, isolate perspective. This is the messiest. + if(LocalMatrix[0][3] != static_cast(0) || LocalMatrix[1][3] != static_cast(0) || LocalMatrix[2][3] != static_cast(0)) + { + // rightHandSide is the right hand side of the equation. + tvec4 RightHandSide; + RightHandSide[0] = LocalMatrix[0][3]; + RightHandSide[1] = LocalMatrix[1][3]; + RightHandSide[2] = LocalMatrix[2][3]; + RightHandSide[3] = LocalMatrix[3][3]; + + // Solve the equation by inverting PerspectiveMatrix and multiplying + // rightHandSide by the inverse. (This is the easiest way, not + // necessarily the best.) + tmat4x4 InversePerspectiveMatrix = glm::inverse(PerspectiveMatrix);// inverse(PerspectiveMatrix, inversePerspectiveMatrix); + tmat4x4 TransposedInversePerspectiveMatrix = glm::transpose(InversePerspectiveMatrix);// transposeMatrix4(inversePerspectiveMatrix, transposedInversePerspectiveMatrix); + + Perspective = TransposedInversePerspectiveMatrix * RightHandSide; + // v4MulPointByMatrix(rightHandSide, transposedInversePerspectiveMatrix, perspectivePoint); + + // Clear the perspective partition + LocalMatrix[0][3] = LocalMatrix[1][3] = LocalMatrix[2][3] = static_cast(0); + LocalMatrix[3][3] = static_cast(1); + } + else + { + // No perspective. + Perspective = tvec4(0, 0, 0, 1); + } + + // Next take care of translation (easy). + Translation = tvec3(LocalMatrix[3]); + LocalMatrix[3] = tvec4(0, 0, 0, LocalMatrix[3].w); + + tvec3 Row[3], Pdum3; + + // Now get scale and shear. + for(length_t i = 0; i < 3; ++i) + for(int j = 0; j < 3; ++j) + Row[i][j] = LocalMatrix[i][j]; + + // Compute X scale factor and normalize first row. + Scale.x = length(Row[0]);// v3Length(Row[0]); + + Row[0] = detail::scale(Row[0], static_cast(1)); + + // Compute XY shear factor and make 2nd row orthogonal to 1st. + Skew.z = dot(Row[0], Row[1]); + Row[1] = detail::combine(Row[1], Row[0], static_cast(1), -Skew.z); + + // Now, compute Y scale and normalize 2nd row. + Scale.y = length(Row[1]); + Row[1] = detail::scale(Row[1], static_cast(1)); + Skew.z /= Scale.y; + + // Compute XZ and YZ shears, orthogonalize 3rd row. + Skew.y = glm::dot(Row[0], Row[2]); + Row[2] = detail::combine(Row[2], Row[0], static_cast(1), -Skew.y); + Skew.x = glm::dot(Row[1], Row[2]); + Row[2] = detail::combine(Row[2], Row[1], static_cast(1), -Skew.x); + + // Next, get Z scale and normalize 3rd row. + Scale.z = length(Row[2]); + Row[2] = detail::scale(Row[2], static_cast(1)); + Skew.y /= Scale.z; + Skew.x /= Scale.z; + + // At this point, the matrix (in rows[]) is orthonormal. + // Check for a coordinate system flip. If the determinant + // is -1, then negate the matrix and the scaling factors. + Pdum3 = cross(Row[1], Row[2]); // v3Cross(row[1], row[2], Pdum3); + if(dot(Row[0], Pdum3) < 0) + { + for(length_t i = 0; i < 3; i++) + { + Scale[i] *= static_cast(-1); + Row[i] *= static_cast(-1); + } + } + + // Now, get the rotations out, as described in the gem. + + // FIXME - Add the ability to return either quaternions (which are + // easier to recompose with) or Euler angles (rx, ry, rz), which + // are easier for authors to deal with. The latter will only be useful + // when we fix https://bugs.webkit.org/show_bug.cgi?id=23799, so I + // will leave the Euler angle code here for now. + + // ret.rotateY = asin(-Row[0][2]); + // if (cos(ret.rotateY) != 0) { + // ret.rotateX = atan2(Row[1][2], Row[2][2]); + // ret.rotateZ = atan2(Row[0][1], Row[0][0]); + // } else { + // ret.rotateX = atan2(-Row[2][0], Row[1][1]); + // ret.rotateZ = 0; + // } + + T s, t, x, y, z, w; + + t = Row[0][0] + Row[1][1] + Row[2][2] + static_cast(1); + + if(t > static_cast(1e-4)) + { + s = static_cast(0.5) / sqrt(t); + w = static_cast(0.25) / s; + x = (Row[2][1] - Row[1][2]) * s; + y = (Row[0][2] - Row[2][0]) * s; + z = (Row[1][0] - Row[0][1]) * s; + } + else if(Row[0][0] > Row[1][1] && Row[0][0] > Row[2][2]) + { + s = sqrt (static_cast(1) + Row[0][0] - Row[1][1] - Row[2][2]) * static_cast(2); // S=4*qx + x = static_cast(0.25) * s; + y = (Row[0][1] + Row[1][0]) / s; + z = (Row[0][2] + Row[2][0]) / s; + w = (Row[2][1] - Row[1][2]) / s; + } + else if(Row[1][1] > Row[2][2]) + { + s = sqrt (static_cast(1) + Row[1][1] - Row[0][0] - Row[2][2]) * static_cast(2); // S=4*qy + x = (Row[0][1] + Row[1][0]) / s; + y = static_cast(0.25) * s; + z = (Row[1][2] + Row[2][1]) / s; + w = (Row[0][2] - Row[2][0]) / s; + } + else + { + s = sqrt(static_cast(1) + Row[2][2] - Row[0][0] - Row[1][1]) * static_cast(2); // S=4*qz + x = (Row[0][2] + Row[2][0]) / s; + y = (Row[1][2] + Row[2][1]) / s; + z = static_cast(0.25) * s; + w = (Row[1][0] - Row[0][1]) / s; + } + + Orientation.x = x; + Orientation.y = y; + Orientation.z = z; + Orientation.w = w; + + return true; + } +}//namespace glm diff --git a/external/include/glm/gtx/matrix_interpolation.hpp b/external/include/glm/gtx/matrix_interpolation.hpp new file mode 100644 index 0000000..77a69ea --- /dev/null +++ b/external/include/glm/gtx/matrix_interpolation.hpp @@ -0,0 +1,61 @@ +/// @ref gtx_matrix_interpolation +/// @file glm/gtx/matrix_interpolation.hpp +/// @author Ghenadii Ursachi (the.asteroth@gmail.com) +/// +/// @see core (dependence) +/// +/// @defgroup gtx_matrix_interpolation GLM_GTX_matrix_interpolation +/// @ingroup gtx +/// +/// @brief Allows to directly interpolate two exiciting matrices. +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../glm.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_matrix_interpolation extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_matrix_interpolation + /// @{ + + /// Get the axis and angle of the rotation from a matrix. + /// From GLM_GTX_matrix_interpolation extension. + template + GLM_FUNC_DECL void axisAngle( + tmat4x4 const & mat, + tvec3 & axis, + T & angle); + + /// Build a matrix from axis and angle. + /// From GLM_GTX_matrix_interpolation extension. + template + GLM_FUNC_DECL tmat4x4 axisAngleMatrix( + tvec3 const & axis, + T const angle); + + /// Extracts the rotation part of a matrix. + /// From GLM_GTX_matrix_interpolation extension. + template + GLM_FUNC_DECL tmat4x4 extractMatrixRotation( + tmat4x4 const & mat); + + /// Build a interpolation of 4 * 4 matrixes. + /// From GLM_GTX_matrix_interpolation extension. + /// Warning! works only with rotation and/or translation matrixes, scale will generate unexpected results. + template + GLM_FUNC_DECL tmat4x4 interpolate( + tmat4x4 const & m1, + tmat4x4 const & m2, + T const delta); + + /// @} +}//namespace glm + +#include "matrix_interpolation.inl" diff --git a/external/include/glm/gtx/matrix_interpolation.inl b/external/include/glm/gtx/matrix_interpolation.inl new file mode 100644 index 0000000..8645f96 --- /dev/null +++ b/external/include/glm/gtx/matrix_interpolation.inl @@ -0,0 +1,134 @@ +/// @ref gtx_matrix_interpolation +/// @file glm/gtx/matrix_interpolation.hpp + +namespace glm +{ + template + GLM_FUNC_QUALIFIER void axisAngle + ( + tmat4x4 const & mat, + tvec3 & axis, + T & angle + ) + { + T epsilon = (T)0.01; + T epsilon2 = (T)0.1; + + if((abs(mat[1][0] - mat[0][1]) < epsilon) && (abs(mat[2][0] - mat[0][2]) < epsilon) && (abs(mat[2][1] - mat[1][2]) < epsilon)) + { + if ((abs(mat[1][0] + mat[0][1]) < epsilon2) && (abs(mat[2][0] + mat[0][2]) < epsilon2) && (abs(mat[2][1] + mat[1][2]) < epsilon2) && (abs(mat[0][0] + mat[1][1] + mat[2][2] - (T)3.0) < epsilon2)) + { + angle = (T)0.0; + axis.x = (T)1.0; + axis.y = (T)0.0; + axis.z = (T)0.0; + return; + } + angle = static_cast(3.1415926535897932384626433832795); + T xx = (mat[0][0] + (T)1.0) / (T)2.0; + T yy = (mat[1][1] + (T)1.0) / (T)2.0; + T zz = (mat[2][2] + (T)1.0) / (T)2.0; + T xy = (mat[1][0] + mat[0][1]) / (T)4.0; + T xz = (mat[2][0] + mat[0][2]) / (T)4.0; + T yz = (mat[2][1] + mat[1][2]) / (T)4.0; + if((xx > yy) && (xx > zz)) + { + if (xx < epsilon) { + axis.x = (T)0.0; + axis.y = (T)0.7071; + axis.z = (T)0.7071; + } else { + axis.x = sqrt(xx); + axis.y = xy / axis.x; + axis.z = xz / axis.x; + } + } + else if (yy > zz) + { + if (yy < epsilon) { + axis.x = (T)0.7071; + axis.y = (T)0.0; + axis.z = (T)0.7071; + } else { + axis.y = sqrt(yy); + axis.x = xy / axis.y; + axis.z = yz / axis.y; + } + } + else + { + if (zz < epsilon) { + axis.x = (T)0.7071; + axis.y = (T)0.7071; + axis.z = (T)0.0; + } else { + axis.z = sqrt(zz); + axis.x = xz / axis.z; + axis.y = yz / axis.z; + } + } + return; + } + T s = sqrt((mat[2][1] - mat[1][2]) * (mat[2][1] - mat[1][2]) + (mat[2][0] - mat[0][2]) * (mat[2][0] - mat[0][2]) + (mat[1][0] - mat[0][1]) * (mat[1][0] - mat[0][1])); + if (glm::abs(s) < T(0.001)) + s = (T)1.0; + angle = acos((mat[0][0] + mat[1][1] + mat[2][2] - (T)1.0) / (T)2.0); + axis.x = (mat[1][2] - mat[2][1]) / s; + axis.y = (mat[2][0] - mat[0][2]) / s; + axis.z = (mat[0][1] - mat[1][0]) / s; + } + + template + GLM_FUNC_QUALIFIER tmat4x4 axisAngleMatrix + ( + tvec3 const & axis, + T const angle + ) + { + T c = cos(angle); + T s = sin(angle); + T t = static_cast(1) - c; + tvec3 n = normalize(axis); + + return tmat4x4( + t * n.x * n.x + c, t * n.x * n.y + n.z * s, t * n.x * n.z - n.y * s, T(0), + t * n.x * n.y - n.z * s, t * n.y * n.y + c, t * n.y * n.z + n.x * s, T(0), + t * n.x * n.z + n.y * s, t * n.y * n.z - n.x * s, t * n.z * n.z + c, T(0), + T(0), T(0), T(0), T(1) + ); + } + + template + GLM_FUNC_QUALIFIER tmat4x4 extractMatrixRotation + ( + tmat4x4 const & mat + ) + { + return tmat4x4( + mat[0][0], mat[0][1], mat[0][2], 0.0, + mat[1][0], mat[1][1], mat[1][2], 0.0, + mat[2][0], mat[2][1], mat[2][2], 0.0, + 0.0, 0.0, 0.0, 1.0 + ); + } + + template + GLM_FUNC_QUALIFIER tmat4x4 interpolate + ( + tmat4x4 const & m1, + tmat4x4 const & m2, + T const delta + ) + { + tmat4x4 m1rot = extractMatrixRotation(m1); + tmat4x4 dltRotation = m2 * transpose(m1rot); + tvec3 dltAxis; + T dltAngle; + axisAngle(dltRotation, dltAxis, dltAngle); + tmat4x4 out = axisAngleMatrix(dltAxis, dltAngle * delta) * m1rot; + out[3][0] = m1[3][0] + delta * (m2[3][0] - m1[3][0]); + out[3][1] = m1[3][1] + delta * (m2[3][1] - m1[3][1]); + out[3][2] = m1[3][2] + delta * (m2[3][2] - m1[3][2]); + return out; + } +}//namespace glm diff --git a/external/include/glm/gtx/matrix_major_storage.hpp b/external/include/glm/gtx/matrix_major_storage.hpp new file mode 100644 index 0000000..9402abe --- /dev/null +++ b/external/include/glm/gtx/matrix_major_storage.hpp @@ -0,0 +1,115 @@ +/// @ref gtx_matrix_major_storage +/// @file glm/gtx/matrix_major_storage.hpp +/// +/// @see core (dependence) +/// @see gtx_extented_min_max (dependence) +/// +/// @defgroup gtx_matrix_major_storage GLM_GTX_matrix_major_storage +/// @ingroup gtx +/// +/// @brief Build matrices with specific matrix order, row or column +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../glm.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_matrix_major_storage extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_matrix_major_storage + /// @{ + + //! Build a row major matrix from row vectors. + //! From GLM_GTX_matrix_major_storage extension. + template + GLM_FUNC_DECL tmat2x2 rowMajor2( + tvec2 const & v1, + tvec2 const & v2); + + //! Build a row major matrix from other matrix. + //! From GLM_GTX_matrix_major_storage extension. + template + GLM_FUNC_DECL tmat2x2 rowMajor2( + tmat2x2 const & m); + + //! Build a row major matrix from row vectors. + //! From GLM_GTX_matrix_major_storage extension. + template + GLM_FUNC_DECL tmat3x3 rowMajor3( + tvec3 const & v1, + tvec3 const & v2, + tvec3 const & v3); + + //! Build a row major matrix from other matrix. + //! From GLM_GTX_matrix_major_storage extension. + template + GLM_FUNC_DECL tmat3x3 rowMajor3( + tmat3x3 const & m); + + //! Build a row major matrix from row vectors. + //! From GLM_GTX_matrix_major_storage extension. + template + GLM_FUNC_DECL tmat4x4 rowMajor4( + tvec4 const & v1, + tvec4 const & v2, + tvec4 const & v3, + tvec4 const & v4); + + //! Build a row major matrix from other matrix. + //! From GLM_GTX_matrix_major_storage extension. + template + GLM_FUNC_DECL tmat4x4 rowMajor4( + tmat4x4 const & m); + + //! Build a column major matrix from column vectors. + //! From GLM_GTX_matrix_major_storage extension. + template + GLM_FUNC_DECL tmat2x2 colMajor2( + tvec2 const & v1, + tvec2 const & v2); + + //! Build a column major matrix from other matrix. + //! From GLM_GTX_matrix_major_storage extension. + template + GLM_FUNC_DECL tmat2x2 colMajor2( + tmat2x2 const & m); + + //! Build a column major matrix from column vectors. + //! From GLM_GTX_matrix_major_storage extension. + template + GLM_FUNC_DECL tmat3x3 colMajor3( + tvec3 const & v1, + tvec3 const & v2, + tvec3 const & v3); + + //! Build a column major matrix from other matrix. + //! From GLM_GTX_matrix_major_storage extension. + template + GLM_FUNC_DECL tmat3x3 colMajor3( + tmat3x3 const & m); + + //! Build a column major matrix from column vectors. + //! From GLM_GTX_matrix_major_storage extension. + template + GLM_FUNC_DECL tmat4x4 colMajor4( + tvec4 const & v1, + tvec4 const & v2, + tvec4 const & v3, + tvec4 const & v4); + + //! Build a column major matrix from other matrix. + //! From GLM_GTX_matrix_major_storage extension. + template + GLM_FUNC_DECL tmat4x4 colMajor4( + tmat4x4 const & m); + + /// @} +}//namespace glm + +#include "matrix_major_storage.inl" diff --git a/external/include/glm/gtx/matrix_major_storage.inl b/external/include/glm/gtx/matrix_major_storage.inl new file mode 100644 index 0000000..7097739 --- /dev/null +++ b/external/include/glm/gtx/matrix_major_storage.inl @@ -0,0 +1,167 @@ +/// @ref gtx_matrix_major_storage +/// @file glm/gtx/matrix_major_storage.hpp + +namespace glm +{ + template + GLM_FUNC_QUALIFIER tmat2x2 rowMajor2 + ( + tvec2 const & v1, + tvec2 const & v2 + ) + { + tmat2x2 Result; + Result[0][0] = v1.x; + Result[1][0] = v1.y; + Result[0][1] = v2.x; + Result[1][1] = v2.y; + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat2x2 rowMajor2( + const tmat2x2& m) + { + tmat2x2 Result; + Result[0][0] = m[0][0]; + Result[0][1] = m[1][0]; + Result[1][0] = m[0][1]; + Result[1][1] = m[1][1]; + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat3x3 rowMajor3( + const tvec3& v1, + const tvec3& v2, + const tvec3& v3) + { + tmat3x3 Result; + Result[0][0] = v1.x; + Result[1][0] = v1.y; + Result[2][0] = v1.z; + Result[0][1] = v2.x; + Result[1][1] = v2.y; + Result[2][1] = v2.z; + Result[0][2] = v3.x; + Result[1][2] = v3.y; + Result[2][2] = v3.z; + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat3x3 rowMajor3( + const tmat3x3& m) + { + tmat3x3 Result; + Result[0][0] = m[0][0]; + Result[0][1] = m[1][0]; + Result[0][2] = m[2][0]; + Result[1][0] = m[0][1]; + Result[1][1] = m[1][1]; + Result[1][2] = m[2][1]; + Result[2][0] = m[0][2]; + Result[2][1] = m[1][2]; + Result[2][2] = m[2][2]; + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat4x4 rowMajor4( + const tvec4& v1, + const tvec4& v2, + const tvec4& v3, + const tvec4& v4) + { + tmat4x4 Result; + Result[0][0] = v1.x; + Result[1][0] = v1.y; + Result[2][0] = v1.z; + Result[3][0] = v1.w; + Result[0][1] = v2.x; + Result[1][1] = v2.y; + Result[2][1] = v2.z; + Result[3][1] = v2.w; + Result[0][2] = v3.x; + Result[1][2] = v3.y; + Result[2][2] = v3.z; + Result[3][2] = v3.w; + Result[0][3] = v4.x; + Result[1][3] = v4.y; + Result[2][3] = v4.z; + Result[3][3] = v4.w; + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat4x4 rowMajor4( + const tmat4x4& m) + { + tmat4x4 Result; + Result[0][0] = m[0][0]; + Result[0][1] = m[1][0]; + Result[0][2] = m[2][0]; + Result[0][3] = m[3][0]; + Result[1][0] = m[0][1]; + Result[1][1] = m[1][1]; + Result[1][2] = m[2][1]; + Result[1][3] = m[3][1]; + Result[2][0] = m[0][2]; + Result[2][1] = m[1][2]; + Result[2][2] = m[2][2]; + Result[2][3] = m[3][2]; + Result[3][0] = m[0][3]; + Result[3][1] = m[1][3]; + Result[3][2] = m[2][3]; + Result[3][3] = m[3][3]; + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat2x2 colMajor2( + const tvec2& v1, + const tvec2& v2) + { + return tmat2x2(v1, v2); + } + + template + GLM_FUNC_QUALIFIER tmat2x2 colMajor2( + const tmat2x2& m) + { + return tmat2x2(m); + } + + template + GLM_FUNC_QUALIFIER tmat3x3 colMajor3( + const tvec3& v1, + const tvec3& v2, + const tvec3& v3) + { + return tmat3x3(v1, v2, v3); + } + + template + GLM_FUNC_QUALIFIER tmat3x3 colMajor3( + const tmat3x3& m) + { + return tmat3x3(m); + } + + template + GLM_FUNC_QUALIFIER tmat4x4 colMajor4( + const tvec4& v1, + const tvec4& v2, + const tvec4& v3, + const tvec4& v4) + { + return tmat4x4(v1, v2, v3, v4); + } + + template + GLM_FUNC_QUALIFIER tmat4x4 colMajor4( + const tmat4x4& m) + { + return tmat4x4(m); + } +}//namespace glm diff --git a/external/include/glm/gtx/matrix_operation.hpp b/external/include/glm/gtx/matrix_operation.hpp new file mode 100644 index 0000000..3192ae5 --- /dev/null +++ b/external/include/glm/gtx/matrix_operation.hpp @@ -0,0 +1,84 @@ +/// @ref gtx_matrix_operation +/// @file glm/gtx/matrix_operation.hpp +/// +/// @see core (dependence) +/// +/// @defgroup gtx_matrix_operation GLM_GTX_matrix_operation +/// @ingroup gtx +/// +/// @brief Build diagonal matrices from vectors. +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../glm.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_matrix_operation extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_matrix_operation + /// @{ + + //! Build a diagonal matrix. + //! From GLM_GTX_matrix_operation extension. + template + GLM_FUNC_DECL tmat2x2 diagonal2x2( + tvec2 const & v); + + //! Build a diagonal matrix. + //! From GLM_GTX_matrix_operation extension. + template + GLM_FUNC_DECL tmat2x3 diagonal2x3( + tvec2 const & v); + + //! Build a diagonal matrix. + //! From GLM_GTX_matrix_operation extension. + template + GLM_FUNC_DECL tmat2x4 diagonal2x4( + tvec2 const & v); + + //! Build a diagonal matrix. + //! From GLM_GTX_matrix_operation extension. + template + GLM_FUNC_DECL tmat3x2 diagonal3x2( + tvec2 const & v); + + //! Build a diagonal matrix. + //! From GLM_GTX_matrix_operation extension. + template + GLM_FUNC_DECL tmat3x3 diagonal3x3( + tvec3 const & v); + + //! Build a diagonal matrix. + //! From GLM_GTX_matrix_operation extension. + template + GLM_FUNC_DECL tmat3x4 diagonal3x4( + tvec3 const & v); + + //! Build a diagonal matrix. + //! From GLM_GTX_matrix_operation extension. + template + GLM_FUNC_DECL tmat4x2 diagonal4x2( + tvec2 const & v); + + //! Build a diagonal matrix. + //! From GLM_GTX_matrix_operation extension. + template + GLM_FUNC_DECL tmat4x3 diagonal4x3( + tvec3 const & v); + + //! Build a diagonal matrix. + //! From GLM_GTX_matrix_operation extension. + template + GLM_FUNC_DECL tmat4x4 diagonal4x4( + tvec4 const & v); + + /// @} +}//namespace glm + +#include "matrix_operation.inl" diff --git a/external/include/glm/gtx/matrix_operation.inl b/external/include/glm/gtx/matrix_operation.inl new file mode 100644 index 0000000..1553215 --- /dev/null +++ b/external/include/glm/gtx/matrix_operation.inl @@ -0,0 +1,118 @@ +/// @ref gtx_matrix_operation +/// @file glm/gtx/matrix_operation.inl + +namespace glm +{ + template + GLM_FUNC_QUALIFIER tmat2x2 diagonal2x2 + ( + tvec2 const & v + ) + { + tmat2x2 Result(static_cast(1)); + Result[0][0] = v[0]; + Result[1][1] = v[1]; + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat2x3 diagonal2x3 + ( + tvec2 const & v + ) + { + tmat2x3 Result(static_cast(1)); + Result[0][0] = v[0]; + Result[1][1] = v[1]; + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat2x4 diagonal2x4 + ( + tvec2 const & v + ) + { + tmat2x4 Result(static_cast(1)); + Result[0][0] = v[0]; + Result[1][1] = v[1]; + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat3x2 diagonal3x2 + ( + tvec2 const & v + ) + { + tmat3x2 Result(static_cast(1)); + Result[0][0] = v[0]; + Result[1][1] = v[1]; + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat3x3 diagonal3x3 + ( + tvec3 const & v + ) + { + tmat3x3 Result(static_cast(1)); + Result[0][0] = v[0]; + Result[1][1] = v[1]; + Result[2][2] = v[2]; + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat3x4 diagonal3x4 + ( + tvec3 const & v + ) + { + tmat3x4 Result(static_cast(1)); + Result[0][0] = v[0]; + Result[1][1] = v[1]; + Result[2][2] = v[2]; + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat4x4 diagonal4x4 + ( + tvec4 const & v + ) + { + tmat4x4 Result(static_cast(1)); + Result[0][0] = v[0]; + Result[1][1] = v[1]; + Result[2][2] = v[2]; + Result[3][3] = v[3]; + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat4x3 diagonal4x3 + ( + tvec3 const & v + ) + { + tmat4x3 Result(static_cast(1)); + Result[0][0] = v[0]; + Result[1][1] = v[1]; + Result[2][2] = v[2]; + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat4x2 diagonal4x2 + ( + tvec2 const & v + ) + { + tmat4x2 Result(static_cast(1)); + Result[0][0] = v[0]; + Result[1][1] = v[1]; + return Result; + } +}//namespace glm diff --git a/external/include/glm/gtx/matrix_query.hpp b/external/include/glm/gtx/matrix_query.hpp new file mode 100644 index 0000000..2518274 --- /dev/null +++ b/external/include/glm/gtx/matrix_query.hpp @@ -0,0 +1,73 @@ +/// @ref gtx_matrix_query +/// @file glm/gtx/matrix_query.hpp +/// +/// @see core (dependence) +/// @see gtx_vector_query (dependence) +/// +/// @defgroup gtx_matrix_query GLM_GTX_matrix_query +/// @ingroup gtx +/// +/// @brief Query to evaluate matrix properties +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../glm.hpp" +#include "../gtx/vector_query.hpp" +#include + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_matrix_query extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_matrix_query + /// @{ + + /// Return whether a matrix a null matrix. + /// From GLM_GTX_matrix_query extension. + template + GLM_FUNC_DECL bool isNull(tmat2x2 const & m, T const & epsilon); + + /// Return whether a matrix a null matrix. + /// From GLM_GTX_matrix_query extension. + template + GLM_FUNC_DECL bool isNull(tmat3x3 const & m, T const & epsilon); + + /// Return whether a matrix is a null matrix. + /// From GLM_GTX_matrix_query extension. + template + GLM_FUNC_DECL bool isNull(tmat4x4 const & m, T const & epsilon); + + /// Return whether a matrix is an identity matrix. + /// From GLM_GTX_matrix_query extension. + template class matType> + GLM_FUNC_DECL bool isIdentity(matType const & m, T const & epsilon); + + /// Return whether a matrix is a normalized matrix. + /// From GLM_GTX_matrix_query extension. + template + GLM_FUNC_DECL bool isNormalized(tmat2x2 const & m, T const & epsilon); + + /// Return whether a matrix is a normalized matrix. + /// From GLM_GTX_matrix_query extension. + template + GLM_FUNC_DECL bool isNormalized(tmat3x3 const & m, T const & epsilon); + + /// Return whether a matrix is a normalized matrix. + /// From GLM_GTX_matrix_query extension. + template + GLM_FUNC_DECL bool isNormalized(tmat4x4 const & m, T const & epsilon); + + /// Return whether a matrix is an orthonormalized matrix. + /// From GLM_GTX_matrix_query extension. + template class matType> + GLM_FUNC_DECL bool isOrthogonal(matType const & m, T const & epsilon); + + /// @} +}//namespace glm + +#include "matrix_query.inl" diff --git a/external/include/glm/gtx/matrix_query.inl b/external/include/glm/gtx/matrix_query.inl new file mode 100644 index 0000000..491b774 --- /dev/null +++ b/external/include/glm/gtx/matrix_query.inl @@ -0,0 +1,114 @@ +/// @ref gtx_matrix_query +/// @file glm/gtx/matrix_query.inl + +namespace glm +{ + template + GLM_FUNC_QUALIFIER bool isNull(tmat2x2 const & m, T const & epsilon) + { + bool result = true; + for(length_t i = 0; result && i < m.length() ; ++i) + result = isNull(m[i], epsilon); + return result; + } + + template + GLM_FUNC_QUALIFIER bool isNull(tmat3x3 const & m, T const & epsilon) + { + bool result = true; + for(length_t i = 0; result && i < m.length() ; ++i) + result = isNull(m[i], epsilon); + return result; + } + + template + GLM_FUNC_QUALIFIER bool isNull(tmat4x4 const & m, T const & epsilon) + { + bool result = true; + for(length_t i = 0; result && i < m.length() ; ++i) + result = isNull(m[i], epsilon); + return result; + } + + template class matType> + GLM_FUNC_QUALIFIER bool isIdentity(matType const & m, T const & epsilon) + { + bool result = true; + for(length_t i = 0; result && i < m[0].length() ; ++i) + { + for(length_t j = 0; result && j < i ; ++j) + result = abs(m[i][j]) <= epsilon; + if(result) + result = abs(m[i][i] - 1) <= epsilon; + for(length_t j = i + 1; result && j < m.length(); ++j) + result = abs(m[i][j]) <= epsilon; + } + return result; + } + + template + GLM_FUNC_QUALIFIER bool isNormalized(tmat2x2 const & m, T const & epsilon) + { + bool result(true); + for(length_t i = 0; result && i < m.length(); ++i) + result = isNormalized(m[i], epsilon); + for(length_t i = 0; result && i < m.length(); ++i) + { + typename tmat2x2::col_type v; + for(length_t j = 0; j < m.length(); ++j) + v[j] = m[j][i]; + result = isNormalized(v, epsilon); + } + return result; + } + + template + GLM_FUNC_QUALIFIER bool isNormalized(tmat3x3 const & m, T const & epsilon) + { + bool result(true); + for(length_t i = 0; result && i < m.length(); ++i) + result = isNormalized(m[i], epsilon); + for(length_t i = 0; result && i < m.length(); ++i) + { + typename tmat3x3::col_type v; + for(length_t j = 0; j < m.length(); ++j) + v[j] = m[j][i]; + result = isNormalized(v, epsilon); + } + return result; + } + + template + GLM_FUNC_QUALIFIER bool isNormalized(tmat4x4 const & m, T const & epsilon) + { + bool result(true); + for(length_t i = 0; result && i < m.length(); ++i) + result = isNormalized(m[i], epsilon); + for(length_t i = 0; result && i < m.length(); ++i) + { + typename tmat4x4::col_type v; + for(length_t j = 0; j < m.length(); ++j) + v[j] = m[j][i]; + result = isNormalized(v, epsilon); + } + return result; + } + + template class matType> + GLM_FUNC_QUALIFIER bool isOrthogonal(matType const & m, T const & epsilon) + { + bool result(true); + for(length_t i(0); result && i < m.length() - 1; ++i) + for(length_t j(i + 1); result && j < m.length(); ++j) + result = areOrthogonal(m[i], m[j], epsilon); + + if(result) + { + matType tmp = transpose(m); + for(length_t i(0); result && i < m.length() - 1 ; ++i) + for(length_t j(i + 1); result && j < m.length(); ++j) + result = areOrthogonal(tmp[i], tmp[j], epsilon); + } + return result; + } +}//namespace glm diff --git a/external/include/glm/gtx/matrix_transform_2d.hpp b/external/include/glm/gtx/matrix_transform_2d.hpp new file mode 100644 index 0000000..91f4834 --- /dev/null +++ b/external/include/glm/gtx/matrix_transform_2d.hpp @@ -0,0 +1,78 @@ +/// @ref gtx_matrix_transform_2d +/// @file glm/gtx/matrix_transform_2d.hpp +/// @author Miguel Ángel Pérez Martínez +/// +/// @see core (dependence) +/// +/// @defgroup gtx_matrix_transform_2d GLM_GTX_matrix_transform_2d +/// @ingroup gtx +/// +/// @brief Defines functions that generate common 2d transformation matrices. +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../mat3x3.hpp" +#include "../vec2.hpp" + + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_matrix_transform_2d extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_matrix_transform_2d + /// @{ + + /// Builds a translation 3 * 3 matrix created from a vector of 2 components. + /// + /// @param m Input matrix multiplied by this translation matrix. + /// @param v Coordinates of a translation vector. + template + GLM_FUNC_QUALIFIER tmat3x3 translate( + tmat3x3 const & m, + tvec2 const & v); + + /// Builds a rotation 3 * 3 matrix created from an angle. + /// + /// @param m Input matrix multiplied by this translation matrix. + /// @param angle Rotation angle expressed in radians if GLM_FORCE_RADIANS is defined or degrees otherwise. + template + GLM_FUNC_QUALIFIER tmat3x3 rotate( + tmat3x3 const & m, + T angle); + + /// Builds a scale 3 * 3 matrix created from a vector of 2 components. + /// + /// @param m Input matrix multiplied by this translation matrix. + /// @param v Coordinates of a scale vector. + template + GLM_FUNC_QUALIFIER tmat3x3 scale( + tmat3x3 const & m, + tvec2 const & v); + + /// Builds an horizontal (parallel to the x axis) shear 3 * 3 matrix. + /// + /// @param m Input matrix multiplied by this translation matrix. + /// @param y Shear factor. + template + GLM_FUNC_QUALIFIER tmat3x3 shearX( + tmat3x3 const & m, + T y); + + /// Builds a vertical (parallel to the y axis) shear 3 * 3 matrix. + /// + /// @param m Input matrix multiplied by this translation matrix. + /// @param x Shear factor. + template + GLM_FUNC_QUALIFIER tmat3x3 shearY( + tmat3x3 const & m, + T x); + + /// @} +}//namespace glm + +#include "matrix_transform_2d.inl" diff --git a/external/include/glm/gtx/matrix_transform_2d.inl b/external/include/glm/gtx/matrix_transform_2d.inl new file mode 100644 index 0000000..bea5670 --- /dev/null +++ b/external/include/glm/gtx/matrix_transform_2d.inl @@ -0,0 +1,69 @@ +/// @ref gtx_matrix_transform_2d +/// @file glm/gtc/matrix_transform_2d.inl +/// @author Miguel Ángel Pérez Martínez + +#include "../trigonometric.hpp" + +namespace glm +{ + + template + GLM_FUNC_QUALIFIER tmat3x3 translate( + tmat3x3 const & m, + tvec2 const & v) + { + tmat3x3 Result(m); + Result[2] = m[0] * v[0] + m[1] * v[1] + m[2]; + return Result; + } + + + template + GLM_FUNC_QUALIFIER tmat3x3 rotate( + tmat3x3 const & m, + T angle) + { + T const a = angle; + T const c = cos(a); + T const s = sin(a); + + tmat3x3 Result(uninitialize); + Result[0] = m[0] * c + m[1] * s; + Result[1] = m[0] * -s + m[1] * c; + Result[2] = m[2]; + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat3x3 scale( + tmat3x3 const & m, + tvec2 const & v) + { + tmat3x3 Result(uninitialize); + Result[0] = m[0] * v[0]; + Result[1] = m[1] * v[1]; + Result[2] = m[2]; + return Result; + } + + template + GLM_FUNC_QUALIFIER tmat3x3 shearX( + tmat3x3 const & m, + T y) + { + tmat3x3 Result(1); + Result[0][1] = y; + return m * Result; + } + + template + GLM_FUNC_QUALIFIER tmat3x3 shearY( + tmat3x3 const & m, + T x) + { + tmat3x3 Result(1); + Result[1][0] = x; + return m * Result; + } + +}//namespace glm diff --git a/external/include/glm/gtx/mixed_product.hpp b/external/include/glm/gtx/mixed_product.hpp new file mode 100644 index 0000000..65861f7 --- /dev/null +++ b/external/include/glm/gtx/mixed_product.hpp @@ -0,0 +1,37 @@ +/// @ref gtx_mixed_product +/// @file glm/gtx/mixed_product.hpp +/// +/// @see core (dependence) +/// +/// @defgroup gtx_mixed_product GLM_GTX_mixed_producte +/// @ingroup gtx +/// +/// @brief Mixed product of 3 vectors. +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../glm.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_mixed_product extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_mixed_product + /// @{ + + /// @brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension) + template + GLM_FUNC_DECL T mixedProduct( + tvec3 const & v1, + tvec3 const & v2, + tvec3 const & v3); + + /// @} +}// namespace glm + +#include "mixed_product.inl" diff --git a/external/include/glm/gtx/mixed_product.inl b/external/include/glm/gtx/mixed_product.inl new file mode 100644 index 0000000..a6ede59 --- /dev/null +++ b/external/include/glm/gtx/mixed_product.inl @@ -0,0 +1,16 @@ +/// @ref gtx_mixed_product +/// @file glm/gtx/mixed_product.inl + +namespace glm +{ + template + GLM_FUNC_QUALIFIER T mixedProduct + ( + tvec3 const & v1, + tvec3 const & v2, + tvec3 const & v3 + ) + { + return dot(cross(v1, v2), v3); + } +}//namespace glm diff --git a/external/include/glm/gtx/norm.hpp b/external/include/glm/gtx/norm.hpp new file mode 100644 index 0000000..b3cb528 --- /dev/null +++ b/external/include/glm/gtx/norm.hpp @@ -0,0 +1,86 @@ +/// @ref gtx_norm +/// @file glm/gtx/norm.hpp +/// +/// @see core (dependence) +/// @see gtx_quaternion (dependence) +/// +/// @defgroup gtx_norm GLM_GTX_norm +/// @ingroup gtx +/// +/// @brief Various ways to compute vector norms. +/// +/// need to be included to use these functionalities. + +#pragma once + +// Dependency: +#include "../detail/func_geometric.hpp" +#include "../gtx/quaternion.hpp" + +#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) +# pragma message("GLM: GLM_GTX_norm extension included") +#endif + +namespace glm +{ + /// @addtogroup gtx_norm + /// @{ + + /// Returns the squared length of x. + /// From GLM_GTX_norm extension. + template class vecType> + GLM_FUNC_DECL T length2( + vecType const & x); + + /// Returns the squared distance between p0 and p1, i.e., length2(p0 - p1). + /// From GLM_GTX_norm extension. + template class vecType> + GLM_FUNC_DECL T distance2( + vecType const & p0, + vecType const & p1); + + //! Returns the L1 norm between x and y. + //! From GLM_GTX_norm extension. + template + GLM_FUNC_DECL T l1Norm( + tvec3 const & x, + tvec3 const & y); + + //! Returns the L1 norm of v. + //! From GLM_GTX_norm extension. + template + GLM_FUNC_DECL T l1Norm( + tvec3 const & v); + + //! Returns the L2 norm between x and y. + //! From GLM_GTX_norm extension. + template + GLM_FUNC_DECL T l2Norm( + tvec3 const & x, + tvec3 const & y); + + //! Returns the L2 norm of v. + //! From GLM_GTX_norm extension. + template + GLM_FUNC_DECL T l2Norm( + tvec3 const & x); + + //! Returns the L norm between x and y. + //! From GLM_GTX_norm extension. + template + GLM_FUNC_DECL T lxNorm( + tvec3 const & x, + tvec3 const & y, + unsigned int Depth); + + //! Returns the L norm of v. + //! From GLM_GTX_norm extension. + template + GLM_FUNC_DECL T lxNorm( + tvec3 const & x, + unsigned int Depth); + + /// @} +}//namespace glm + +#include "norm.inl" diff --git a/external/include/glm/gtx/norm.inl b/external/include/glm/gtx/norm.inl new file mode 100644 index 0000000..20954ec --- /dev/null +++ b/external/include/glm/gtx/norm.inl @@ -0,0 +1,106 @@ +/// @ref gtx_norm +/// @file glm/gtx/norm.inl + +#include "../detail/precision.hpp" + +namespace glm{ +namespace detail +{ + template