From a805fb9d68e4eca4bf8172559444cf688c4cc4e4 Mon Sep 17 00:00:00 2001 From: Christophe Riccio Date: Tue, 15 Aug 2017 21:23:47 +0200 Subject: [PATCH] Renamed precision enum to qualifier --- glm/detail/_noise.hpp | 18 +- glm/detail/_swizzle.hpp | 18 +- glm/detail/_vectorize.hpp | 30 +- glm/detail/func_common.hpp | 108 +-- glm/detail/func_common.inl | 116 +-- glm/detail/func_common_simd.inl | 38 +- glm/detail/func_exponential.hpp | 28 +- glm/detail/func_exponential.inl | 20 +- glm/detail/func_exponential_simd.inl | 2 +- glm/detail/func_geometric.hpp | 16 +- glm/detail/func_geometric.inl | 40 +- glm/detail/func_geometric_simd.inl | 16 +- glm/detail/func_integer.hpp | 22 +- glm/detail/func_integer.inl | 38 +- glm/detail/func_integer_simd.inl | 4 +- glm/detail/func_matrix.hpp | 36 +- glm/detail/func_matrix.inl | 48 +- glm/detail/func_matrix_simd.inl | 8 +- glm/detail/func_packing.hpp | 2 +- glm/detail/func_trigonometric.hpp | 62 +- glm/detail/func_trigonometric.inl | 30 +- glm/detail/func_vector_relational.hpp | 20 +- glm/detail/func_vector_relational.inl | 18 +- glm/detail/qualifier.hpp | 12 +- glm/detail/type_float.hpp | 12 +- glm/detail/type_int.hpp | 24 +- glm/detail/type_mat.hpp | 264 +++--- glm/detail/type_mat2x2.hpp | 50 +- glm/detail/type_mat2x2.inl | 114 +-- glm/detail/type_mat2x3.hpp | 40 +- glm/detail/type_mat2x3.inl | 100 +-- glm/detail/type_mat2x4.hpp | 40 +- glm/detail/type_mat2x4.inl | 100 +-- glm/detail/type_mat3x2.hpp | 40 +- glm/detail/type_mat3x2.inl | 100 +-- glm/detail/type_mat3x3.hpp | 50 +- glm/detail/type_mat3x3.inl | 114 +-- glm/detail/type_mat3x4.hpp | 40 +- glm/detail/type_mat3x4.inl | 100 +-- glm/detail/type_mat4x2.hpp | 40 +- glm/detail/type_mat4x2.inl | 100 +-- glm/detail/type_mat4x3.hpp | 40 +- glm/detail/type_mat4x3.inl | 100 +-- glm/detail/type_mat4x4.hpp | 50 +- glm/detail/type_mat4x4.inl | 114 +-- glm/detail/type_vec.hpp | 160 ++-- glm/detail/type_vec1.hpp | 86 +- glm/detail/type_vec1.inl | 156 ++-- glm/detail/type_vec2.hpp | 124 +-- glm/detail/type_vec2.inl | 218 ++--- glm/detail/type_vec3.hpp | 130 +-- glm/detail/type_vec3.inl | 230 ++--- glm/detail/type_vec4.hpp | 142 +-- glm/detail/type_vec4.inl | 280 +++--- glm/detail/type_vec4_simd.inl | 54 +- glm/fwd.hpp | 1046 +++++++++++----------- glm/glm.hpp | 16 +- glm/gtc/bitfield.hpp | 20 +- glm/gtc/bitfield.inl | 18 +- glm/gtc/color_space.hpp | 18 +- glm/gtc/color_space.inl | 54 +- glm/gtc/epsilon.hpp | 6 +- glm/gtc/epsilon.inl | 12 +- glm/gtc/functions.hpp | 4 +- glm/gtc/functions.inl | 2 +- glm/gtc/integer.hpp | 10 +- glm/gtc/integer.inl | 8 +- glm/gtc/matrix_integer.hpp | 144 +-- glm/gtc/matrix_inverse.hpp | 4 +- glm/gtc/matrix_inverse.inl | 10 +- glm/gtc/matrix_transform.hpp | 18 +- glm/gtc/matrix_transform.inl | 22 +- glm/gtc/noise.hpp | 16 +- glm/gtc/noise.inl | 22 +- glm/gtc/packing.hpp | 32 +- glm/gtc/packing.inl | 42 +- glm/gtc/quaternion.hpp | 88 +- glm/gtc/quaternion.inl | 144 +-- glm/gtc/quaternion_simd.inl | 22 +- glm/gtc/random.hpp | 4 +- glm/gtc/random.inl | 38 +- glm/gtc/reciprocal.inl | 48 +- glm/gtc/round.hpp | 20 +- glm/gtc/round.inl | 26 +- glm/gtc/type_aligned.hpp | 152 ++-- glm/gtc/type_precision.hpp | 326 +++---- glm/gtc/type_ptr.inl | 52 +- glm/gtc/ulp.hpp | 6 +- glm/gtc/ulp.inl | 30 +- glm/gtc/vec1.hpp | 60 +- glm/gtx/associated_min_max.hpp | 158 ++-- glm/gtx/associated_min_max.inl | 190 ++-- glm/gtx/bit.hpp | 16 +- glm/gtx/bit.inl | 20 +- glm/gtx/closest_point.hpp | 4 +- glm/gtx/closest_point.inl | 4 +- glm/gtx/color_encoding.hpp | 10 +- glm/gtx/color_encoding.inl | 8 +- glm/gtx/color_space.hpp | 10 +- glm/gtx/color_space.inl | 10 +- glm/gtx/color_space_YCoCg.hpp | 8 +- glm/gtx/color_space_YCoCg.inl | 12 +- glm/gtx/common.hpp | 4 +- glm/gtx/common.inl | 30 +- glm/gtx/compatibility.hpp | 92 +- glm/gtx/compatibility.inl | 8 +- glm/gtx/component_wise.hpp | 14 +- glm/gtx/component_wise.inl | 78 +- glm/gtx/dual_quaternion.hpp | 70 +- glm/gtx/dual_quaternion.inl | 76 +- glm/gtx/euler_angles.hpp | 4 +- glm/gtx/euler_angles.inl | 4 +- glm/gtx/extend.inl | 6 +- glm/gtx/exterior_product.hpp | 4 +- glm/gtx/exterior_product.inl | 4 +- glm/gtx/fast_exponential.hpp | 24 +- glm/gtx/fast_exponential.inl | 26 +- glm/gtx/fast_square_root.hpp | 16 +- glm/gtx/fast_square_root.inl | 20 +- glm/gtx/fast_trigonometry.inl | 40 +- glm/gtx/float_notmalize.inl | 6 +- glm/gtx/gradient_paint.hpp | 4 +- glm/gtx/gradient_paint.inl | 4 +- glm/gtx/handed_coordinate_space.hpp | 4 +- glm/gtx/handed_coordinate_space.inl | 4 +- glm/gtx/hash.hpp | 30 +- glm/gtx/hash.inl | 30 +- glm/gtx/integer.inl | 6 +- glm/gtx/intersect.hpp | 2 +- glm/gtx/intersect.inl | 2 +- glm/gtx/io.hpp | 32 +- glm/gtx/io.inl | 34 +- glm/gtx/log_base.hpp | 8 +- glm/gtx/log_base.inl | 6 +- glm/gtx/matrix_cross_product.hpp | 4 +- glm/gtx/matrix_cross_product.inl | 4 +- glm/gtx/matrix_decompose.hpp | 2 +- glm/gtx/matrix_decompose.inl | 6 +- glm/gtx/matrix_factorisation.hpp | 8 +- glm/gtx/matrix_factorisation.inl | 8 +- glm/gtx/matrix_interpolation.hpp | 8 +- glm/gtx/matrix_interpolation.inl | 8 +- glm/gtx/matrix_major_storage.hpp | 24 +- glm/gtx/matrix_major_storage.inl | 24 +- glm/gtx/matrix_operation.hpp | 18 +- glm/gtx/matrix_operation.inl | 18 +- glm/gtx/matrix_query.hpp | 16 +- glm/gtx/matrix_query.inl | 36 +- glm/gtx/matrix_transform_2d.hpp | 10 +- glm/gtx/matrix_transform_2d.inl | 10 +- glm/gtx/mixed_product.hpp | 2 +- glm/gtx/mixed_product.inl | 2 +- glm/gtx/norm.hpp | 50 +- glm/gtx/norm.inl | 62 +- glm/gtx/normal.hpp | 2 +- glm/gtx/normal.inl | 2 +- glm/gtx/normalize_dot.hpp | 8 +- glm/gtx/normalize_dot.inl | 8 +- glm/gtx/number_precision.hpp | 12 +- glm/gtx/orthonormalize.hpp | 4 +- glm/gtx/orthonormalize.inl | 4 +- glm/gtx/perpendicular.hpp | 6 +- glm/gtx/perpendicular.inl | 8 +- glm/gtx/polar_coordinates.hpp | 4 +- glm/gtx/polar_coordinates.inl | 4 +- glm/gtx/projection.hpp | 4 +- glm/gtx/projection.inl | 4 +- glm/gtx/quaternion.hpp | 47 +- glm/gtx/quaternion.inl | 36 +- glm/gtx/range.hpp | 8 +- glm/gtx/rotate_normalized_axis.hpp | 4 +- glm/gtx/rotate_normalized_axis.inl | 4 +- glm/gtx/rotate_vector.hpp | 22 +- glm/gtx/rotate_vector.inl | 24 +- glm/gtx/string_cast.inl | 38 +- glm/gtx/transform.hpp | 6 +- glm/gtx/transform.inl | 6 +- glm/gtx/transform2.hpp | 18 +- glm/gtx/transform2.inl | 22 +- glm/gtx/type_aligned.hpp | 434 ++++----- glm/gtx/type_trait.hpp | 24 +- glm/gtx/vec_swizzle.hpp | 968 ++++++++++---------- glm/gtx/vector_angle.hpp | 19 +- glm/gtx/vector_angle.inl | 25 +- glm/gtx/vector_query.hpp | 24 +- glm/gtx/vector_query.inl | 108 +-- glm/gtx/wrap.inl | 30 +- glm/mat2x2.hpp | 24 +- glm/mat2x3.hpp | 12 +- glm/mat2x4.hpp | 12 +- glm/mat3x2.hpp | 12 +- glm/mat3x3.hpp | 24 +- glm/mat3x4.hpp | 12 +- glm/mat4x2.hpp | 12 +- glm/mat4x3.hpp | 12 +- glm/mat4x4.hpp | 24 +- test/core/core_func_integer.cpp | 14 +- test/core/core_func_integer_find_msb.cpp | 2 +- test/gtx/gtx_fast_trigonometry.cpp | 78 +- test/gtx/gtx_io.cpp | 10 +- test/gtx/gtx_matrix_factorisation.cpp | 4 +- 201 files changed, 5026 insertions(+), 5127 deletions(-) diff --git a/glm/detail/_noise.hpp b/glm/detail/_noise.hpp index cdee4547..68629ca4 100644 --- a/glm/detail/_noise.hpp +++ b/glm/detail/_noise.hpp @@ -23,19 +23,19 @@ namespace detail return mod289(((x * static_cast(34)) + static_cast(1)) * x); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> permute(vec<2, T, P> const & x) { return mod289(((x * static_cast(34)) + static_cast(1)) * x); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> permute(vec<3, T, P> const & x) { return mod289(((x * static_cast(34)) + static_cast(1)) * x); } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> permute(vec<4, T, P> const & x) { return mod289(((x * static_cast(34)) + static_cast(1)) * x); @@ -47,37 +47,37 @@ namespace detail return T(1.79284291400159) - T(0.85373472095314) * r; } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> taylorInvSqrt(vec<2, T, P> const & r) { return T(1.79284291400159) - T(0.85373472095314) * r; } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> taylorInvSqrt(vec<3, T, P> const & r) { return T(1.79284291400159) - T(0.85373472095314) * r; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> taylorInvSqrt(vec<4, T, P> const & r) { return T(1.79284291400159) - T(0.85373472095314) * r; } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> fade(vec<2, T, P> const & t) { return (t * t * t) * (t * (t * T(6) - T(15)) + T(10)); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> fade(vec<3, T, P> const & t) { return (t * t * t) * (t * (t * T(6) - T(15)) + T(10)); } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> fade(vec<4, T, P> const & t) { return (t * t * t) * (t * (t * T(6) - T(15)) + T(10)); diff --git a/glm/detail/_swizzle.hpp b/glm/detail/_swizzle.hpp index 8ebea190..0eb5805a 100644 --- a/glm/detail/_swizzle.hpp +++ b/glm/detail/_swizzle.hpp @@ -20,24 +20,24 @@ namespace detail char _buffer[1]; }; - template + template struct _swizzle_base1 : public _swizzle_base0 { }; - template + template struct _swizzle_base1<2, T, P, E0,E1,-1,-2, Aligned> : public _swizzle_base0 { GLM_FUNC_QUALIFIER vec<2, T, P> operator ()() const { return vec<2, T, P>(this->elem(E0), this->elem(E1)); } }; - template + template struct _swizzle_base1<3, T, P, E0,E1,E2,-1, Aligned> : public _swizzle_base0 { GLM_FUNC_QUALIFIER vec<3, T, P> operator ()() const { return vec<3, T, P>(this->elem(E0), this->elem(E1), this->elem(E2)); } }; - template + template struct _swizzle_base1<4, T, P, E0,E1,E2,E3, Aligned> : public _swizzle_base0 { GLM_FUNC_QUALIFIER vec<4, T, P> operator ()() const { return vec<4, T, P>(this->elem(E0), this->elem(E1), this->elem(E2), this->elem(E3)); } @@ -54,7 +54,7 @@ namespace detail DUPLICATE_ELEMENTS = 1 if there is a repeated element, 0 otherwise (used to specialize swizzles containing duplicate elements so that they cannot be used as r-values). */ - template + template struct _swizzle_base2 : public _swizzle_base1::value> { GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const T& t) @@ -132,7 +132,7 @@ namespace detail }; // Specialization for swizzles containing duplicate elements. These cannot be modified. - template + template struct _swizzle_base2 : public _swizzle_base1::value> { struct Stub {}; @@ -146,7 +146,7 @@ namespace detail } }; - template + template struct _swizzle : public _swizzle_base2 { typedef _swizzle_base2 base_type; @@ -159,8 +159,8 @@ namespace detail // // To prevent the C++ syntax from getting entirely overwhelming, define some alias macros // -#define GLM_SWIZZLE_TEMPLATE1 template -#define GLM_SWIZZLE_TEMPLATE2 template +#define GLM_SWIZZLE_TEMPLATE1 template +#define GLM_SWIZZLE_TEMPLATE2 template #define GLM_SWIZZLE_TYPE1 _swizzle #define GLM_SWIZZLE_TYPE2 _swizzle diff --git a/glm/detail/_vectorize.hpp b/glm/detail/_vectorize.hpp index 44fb0b5d..ca84184f 100644 --- a/glm/detail/_vectorize.hpp +++ b/glm/detail/_vectorize.hpp @@ -11,10 +11,10 @@ namespace glm{ namespace detail { - template + template struct functor1{}; - template + template struct functor1<1, R, T, P> { GLM_FUNC_QUALIFIER static vec<1, R, P> call(R (*Func) (T x), vec<1, T, P> const & v) @@ -23,7 +23,7 @@ namespace detail } }; - template + template struct functor1<2, R, T, P> { GLM_FUNC_QUALIFIER static vec<2, R, P> call(R (*Func) (T x), vec<2, T, P> const & v) @@ -32,7 +32,7 @@ namespace detail } }; - template + template struct functor1<3, R, T, P> { GLM_FUNC_QUALIFIER static vec<3, R, P> call(R (*Func) (T x), vec<3, T, P> const & v) @@ -41,7 +41,7 @@ namespace detail } }; - template + template struct functor1<4, R, T, P> { GLM_FUNC_QUALIFIER static vec<4, R, P> call(R (*Func) (T x), vec<4, T, P> const & v) @@ -50,10 +50,10 @@ namespace detail } }; - template + template struct functor2{}; - template + template struct functor2<1, T, P> { GLM_FUNC_QUALIFIER static vec<1, T, P> call(T (*Func) (T x, T y), vec<1, T, P> const & a, vec<1, T, P> const & b) @@ -62,7 +62,7 @@ namespace detail } }; - template + template struct functor2<2, T, P> { GLM_FUNC_QUALIFIER static vec<2, T, P> call(T (*Func) (T x, T y), vec<2, T, P> const & a, vec<2, T, P> const & b) @@ -71,7 +71,7 @@ namespace detail } }; - template + template struct functor2<3, T, P> { GLM_FUNC_QUALIFIER static vec<3, T, P> call(T (*Func) (T x, T y), vec<3, T, P> const & a, vec<3, T, P> const & b) @@ -80,7 +80,7 @@ namespace detail } }; - template + template struct functor2<4, T, P> { GLM_FUNC_QUALIFIER static vec<4, T, P> call(T (*Func) (T x, T y), vec<4, T, P> const & a, vec<4, T, P> const & b) @@ -89,10 +89,10 @@ namespace detail } }; - template + template struct functor2_vec_sca{}; - template + template struct functor2_vec_sca<1, T, P> { GLM_FUNC_QUALIFIER static vec<1, T, P> call(T (*Func) (T x, T y), vec<1, T, P> const & a, T b) @@ -101,7 +101,7 @@ namespace detail } }; - template + template struct functor2_vec_sca<2, T, P> { GLM_FUNC_QUALIFIER static vec<2, T, P> call(T (*Func) (T x, T y), vec<2, T, P> const & a, T b) @@ -110,7 +110,7 @@ namespace detail } }; - template + template struct functor2_vec_sca<3, T, P> { GLM_FUNC_QUALIFIER static vec<3, T, P> call(T (*Func) (T x, T y), vec<3, T, P> const & a, T b) @@ -119,7 +119,7 @@ namespace detail } }; - template + template struct functor2_vec_sca<4, T, P> { GLM_FUNC_QUALIFIER static vec<4, T, P> call(T (*Func) (T x, T y), vec<4, T, P> const & a, T b) diff --git a/glm/detail/func_common.hpp b/glm/detail/func_common.hpp index b5cb10ae..1fce0dfd 100644 --- a/glm/detail/func_common.hpp +++ b/glm/detail/func_common.hpp @@ -11,7 +11,7 @@ #pragma once #include "setup.hpp" -#include "precision.hpp" +#include "qualifier.hpp" #include "type_int.hpp" #include "_fixes.hpp" @@ -26,7 +26,7 @@ namespace glm /// /// @see GLSL abs man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - /// @see precision + /// @see qualifier template GLM_FUNC_DECL genType abs(genType x); @@ -34,33 +34,33 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or signed integer scalar types - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL abs man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec abs(vec const& x); /// Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL sign man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec sign(vec const& x); /// Returns a value equal to the nearest integer that is less then or equal to x. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL floor man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec floor(vec const& x); /// Returns a value equal to the nearest integer to x @@ -68,11 +68,11 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL trunc man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec trunc(vec const& x); /// Returns a value equal to the nearest integer to x. @@ -83,11 +83,11 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL round man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec round(vec const& x); /// Returns a value equal to the nearest integer to x. @@ -96,12 +96,12 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL roundEven man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions /// @see New round to even technique - template + template GLM_FUNC_DECL vec roundEven(vec const& x); /// Returns a value equal to the nearest integer @@ -109,11 +109,11 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL ceil man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec ceil(vec const& x); /// Return x - floor(x). @@ -129,11 +129,11 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL fract man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec fract(vec const& x); /// Modulus. Returns x - y * floor(x / y) @@ -151,11 +151,11 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL mod man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec mod(vec const& x, T y); /// Modulus. Returns x - y * floor(x / y) @@ -163,11 +163,11 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL mod man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec mod(vec const& x, vec const& y); /// Returns the fractional part of x and sets i to the integer @@ -195,22 +195,22 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL min man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec min(vec const& x, T y); /// Returns y if y < x; otherwise, it returns x. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL min man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec min(vec const& x, vec const& y); /// Returns y if x < y; otherwise, it returns x. @@ -226,22 +226,22 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL max man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec max(vec const& x, T y); /// Returns y if x < y; otherwise, it returns x. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL max man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec max(vec const& x, vec const& y); /// Returns min(max(x, minVal), maxVal) for each component in x @@ -259,11 +259,11 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL clamp man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec clamp(vec const & x, T minVal, T maxVal); /// Returns min(max(x, minVal), maxVal) for each component in x @@ -271,11 +271,11 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point or integer scalar types - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL clamp man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec clamp(vec const& x, vec const& minVal, vec const& maxVal); /// If genTypeU is a floating scalar or vector: @@ -323,10 +323,10 @@ namespace glm template GLM_FUNC_DECL genTypeT mix(genTypeT x, genTypeT y, genTypeU a); - template + template GLM_FUNC_DECL vec mix(vec const& x, vec const& y, vec const& a); - template + template GLM_FUNC_DECL vec mix(vec const& x, vec const& y, U a); /// Returns 0.0 if x < edge, otherwise it returns 1.0 for each component of a genType. @@ -340,22 +340,22 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL step man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec step(T edge, vec const& x); /// Returns 0.0 if x < edge, otherwise it returns 1.0. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL step man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec step(vec const& edge, vec const& x); /// Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and @@ -375,10 +375,10 @@ namespace glm template GLM_FUNC_DECL genType smoothstep(genType edge0, genType edge1, genType x); - template + template GLM_FUNC_DECL vec smoothstep(T edge0, T edge1, vec const& x); - template + template GLM_FUNC_DECL vec smoothstep(vec const& edge0, vec const& edge1, vec const& x); /// Returns true if x holds a NaN (not a number) @@ -391,11 +391,11 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL isnan man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec isnan(vec const& x); /// Returns true if x holds a positive infinity or negative @@ -406,11 +406,11 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL isinf man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec isinf(vec const& x); /// Returns a signed integer value representing @@ -426,11 +426,11 @@ namespace glm /// value's bit-level representation is preserved. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL floatBitsToInt man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec floatBitsToInt(vec const& v); /// Returns a unsigned integer value representing @@ -446,11 +446,11 @@ namespace glm /// value's bit-level representation is preserved. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL floatBitsToUint man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec floatBitsToUint(vec const& v); /// Returns a floating-point value corresponding to a signed @@ -470,11 +470,11 @@ namespace glm /// the bit-level representation is preserved. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL intBitsToFloat man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec intBitsToFloat(vec const& v); /// Returns a floating-point value corresponding to a @@ -494,11 +494,11 @@ namespace glm /// the bit-level representation is preserved. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector - /// @tparam P Value from precision enum + /// @tparam P Value from qualifier enum /// /// @see GLSL uintBitsToFloat man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec uintBitsToFloat(vec const& v); /// Computes and returns a * b + c. diff --git a/glm/detail/func_common.inl b/glm/detail/func_common.inl index 24a486bb..a1a1851f 100644 --- a/glm/detail/func_common.inl +++ b/glm/detail/func_common.inl @@ -107,7 +107,7 @@ namespace detail } }; - template + template struct compute_abs_vector { GLM_FUNC_QUALIFIER static vec call(vec const & x) @@ -116,7 +116,7 @@ namespace detail } }; - template + template struct compute_mix_vector { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& y, vec const& a) @@ -127,7 +127,7 @@ namespace detail } }; - template + template struct compute_mix_vector { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& y, vec const& a) @@ -139,7 +139,7 @@ namespace detail } }; - template + template struct compute_mix_scalar { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& y, U const& a) @@ -150,7 +150,7 @@ namespace detail } }; - template + template struct compute_mix_scalar { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& y, bool const& a) @@ -179,7 +179,7 @@ namespace detail } }; - template + template struct compute_sign { GLM_FUNC_QUALIFIER static vec call(vec const& x) @@ -189,7 +189,7 @@ namespace detail }; # if GLM_ARCH == GLM_ARCH_X86 - template + template struct compute_sign { GLM_FUNC_QUALIFIER static vec call(vec const& x) @@ -202,7 +202,7 @@ namespace detail }; # endif - template + template struct compute_floor { GLM_FUNC_QUALIFIER static vec call(vec const& x) @@ -211,7 +211,7 @@ namespace detail } }; - template + template struct compute_ceil { GLM_FUNC_QUALIFIER static vec call(vec const& x) @@ -220,7 +220,7 @@ namespace detail } }; - template + template struct compute_fract { GLM_FUNC_QUALIFIER static vec call(vec const& x) @@ -229,7 +229,7 @@ namespace detail } }; - template + template struct compute_trunc { GLM_FUNC_QUALIFIER static vec call(vec const& x) @@ -238,7 +238,7 @@ namespace detail } }; - template + template struct compute_round { GLM_FUNC_QUALIFIER static vec call(vec const& x) @@ -247,7 +247,7 @@ namespace detail } }; - template + template struct compute_mod { GLM_FUNC_QUALIFIER static vec call(vec const& a, vec const& b) @@ -257,7 +257,7 @@ namespace detail } }; - template + template struct compute_min_vector { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& y) @@ -266,7 +266,7 @@ namespace detail } }; - template + template struct compute_max_vector { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& y) @@ -275,7 +275,7 @@ namespace detail } }; - template + template struct compute_clamp_vector { GLM_FUNC_QUALIFIER static vec call(vec const& x, vec const& minVal, vec const& maxVal) @@ -284,7 +284,7 @@ namespace detail } }; - template + template struct compute_step_vector { GLM_FUNC_QUALIFIER static vec call(vec const& edge, vec const& x) @@ -293,7 +293,7 @@ namespace detail } }; - template + template struct compute_smoothstep_vector { GLM_FUNC_QUALIFIER static vec call(vec const& edge0, vec const& edge1, vec const& x) @@ -311,7 +311,7 @@ namespace detail return detail::compute_abs::is_signed>::call(x); } - template + template GLM_FUNC_QUALIFIER vec abs(vec const & x) { return detail::compute_abs_vector::value>::call(x); @@ -329,7 +329,7 @@ namespace detail return detail::compute_sign<1, genFIType, defaultp, std::numeric_limits::is_iec559, highp>::call(vec<1, genFIType>(x)).x; } - template + template GLM_FUNC_QUALIFIER vec sign(vec const& x) { GLM_STATIC_ASSERT( @@ -341,21 +341,21 @@ namespace detail // floor using ::std::floor; - template + template GLM_FUNC_QUALIFIER vec floor(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'floor' only accept floating-point inputs."); return detail::compute_floor::value>::call(x); } - template + template GLM_FUNC_QUALIFIER vec trunc(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'trunc' only accept floating-point inputs"); return detail::compute_trunc::value>::call(x); } - template + template GLM_FUNC_QUALIFIER vec round(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'round' only accept floating-point inputs"); @@ -405,7 +405,7 @@ namespace detail //} } - template + template GLM_FUNC_QUALIFIER vec roundEven(vec const & x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'roundEven' only accept floating-point inputs"); @@ -414,7 +414,7 @@ namespace detail // ceil using ::std::ceil; - template + template GLM_FUNC_QUALIFIER vec ceil(vec const & x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'ceil' only accept floating-point inputs"); @@ -428,7 +428,7 @@ namespace detail return fract(vec<1, genType>(x)).x; } - template + template GLM_FUNC_QUALIFIER vec fract(vec const & x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fract' only accept floating-point inputs"); @@ -448,13 +448,13 @@ namespace detail # endif } - template + template GLM_FUNC_QUALIFIER vec mod(vec const & x, T y) { return detail::compute_mod::value>::call(x, vec(y)); } - template + template GLM_FUNC_QUALIFIER vec mod(vec const& x, vec const& y) { return detail::compute_mod::value>::call(x, y); @@ -468,14 +468,14 @@ namespace detail return std::modf(x, &i); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> modf(vec<1, T, P> const & x, vec<1, T, P> & i) { return vec<1, T, P>( modf(x.x, i.x)); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> modf(vec<2, T, P> const & x, vec<2, T, P> & i) { return vec<2, T, P>( @@ -483,7 +483,7 @@ namespace detail modf(x.y, i.y)); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> modf(vec<3, T, P> const & x, vec<3, T, P> & i) { return vec<3, T, P>( @@ -492,7 +492,7 @@ namespace detail modf(x.z, i.z)); } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> modf(vec<4, T, P> const & x, vec<4, T, P> & i) { return vec<4, T, P>( @@ -511,28 +511,28 @@ namespace detail //CHAR_BIT - 1))); // min - template + template GLM_FUNC_QUALIFIER vec min(vec const & a, T b) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "'min' only accept floating-point or integer inputs"); return detail::compute_min_vector::value>::call(a, vec(b)); } - template + template GLM_FUNC_QUALIFIER vec min(vec const& a, vec const& b) { return detail::compute_min_vector::value>::call(a, b); } // max - template + template GLM_FUNC_QUALIFIER vec max(vec const& a, T b) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "'max' only accept floating-point or integer inputs"); return detail::compute_max_vector::value>::call(a, vec(b)); } - template + template GLM_FUNC_QUALIFIER vec max(vec const& a, vec const & b) { return detail::compute_max_vector::value>::call(a, b); @@ -546,14 +546,14 @@ namespace detail return min(max(x, minVal), maxVal); } - template + template GLM_FUNC_QUALIFIER vec clamp(vec const & x, T minVal, T maxVal) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "'clamp' only accept floating-point or integer inputs"); return detail::compute_clamp_vector::value>::call(x, vec(minVal), vec(maxVal)); } - template + template GLM_FUNC_QUALIFIER vec clamp(vec const& x, vec const& minVal, vec const& maxVal) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || std::numeric_limits::is_integer || GLM_UNRESTRICTED_GENTYPE, "'clamp' only accept floating-point or integer inputs"); @@ -566,13 +566,13 @@ namespace detail return detail::compute_mix::call(x, y, a); } - template + template GLM_FUNC_QUALIFIER vec mix(vec const& x, vec const& y, U a) { return detail::compute_mix_scalar::value>::call(x, y, a); } - template + template GLM_FUNC_QUALIFIER vec mix(vec const& x, vec const& y, vec const& a) { return detail::compute_mix_vector::value>::call(x, y, a); @@ -585,13 +585,13 @@ namespace detail return mix(static_cast(1), static_cast(0), glm::lessThan(x, edge)); } - template + template GLM_FUNC_QUALIFIER vec step(T edge, vec const& x) { return detail::compute_step_vector::value>::call(vec(edge), x); } - template + template GLM_FUNC_QUALIFIER vec step(vec const& edge, vec const& x) { return detail::compute_step_vector::value>::call(edge, x); @@ -607,13 +607,13 @@ namespace detail return tmp * tmp * (genType(3) - genType(2) * tmp); } - template + template GLM_FUNC_QUALIFIER vec smoothstep(T edge0, T edge1, vec const& x) { return detail::compute_smoothstep_vector::value>::call(vec(edge0), vec(edge1), x); } - template + template GLM_FUNC_QUALIFIER vec smoothstep(vec const& edge0, vec const& edge1, vec const& x) { return detail::compute_smoothstep_vector::value>::call(edge0, edge1, x); @@ -647,7 +647,7 @@ namespace detail } # endif - template + template GLM_FUNC_QUALIFIER vec isnan(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isnan' only accept floating-point inputs"); @@ -686,7 +686,7 @@ namespace detail } # endif - template + template GLM_FUNC_QUALIFIER vec isinf(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isnan' only accept floating-point inputs"); @@ -707,7 +707,7 @@ namespace detail return u.out; } - template + template GLM_FUNC_QUALIFIER vec floatBitsToInt(vec const& v) { return reinterpret_cast&>(const_cast&>(v)); @@ -726,7 +726,7 @@ namespace detail return u.out; } - template + template GLM_FUNC_QUALIFIER vec floatBitsToUint(vec const& v) { return reinterpret_cast&>(const_cast&>(v)); @@ -745,7 +745,7 @@ namespace detail return u.out; } - template + template GLM_FUNC_QUALIFIER vec intBitsToFloat(vec const& v) { return reinterpret_cast&>(const_cast&>(v)); @@ -764,7 +764,7 @@ namespace detail return u.out; } - template + template GLM_FUNC_QUALIFIER vec uintBitsToFloat(vec const& v) { return reinterpret_cast&>(const_cast&>(v)); @@ -784,7 +784,7 @@ namespace detail return std::frexp(x, &exp); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> frexp(vec<1, T, P> const& x, vec<1, int, P>& exp) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs"); @@ -792,7 +792,7 @@ namespace detail return vec<1, T, P>(std::frexp(x.x, &exp.x)); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> frexp(vec<2, T, P> const& x, vec<2, int, P>& exp) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs"); @@ -802,7 +802,7 @@ namespace detail frexp(x.y, exp.y)); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> frexp(vec<3, T, P> const& x, vec<3, int, P>& exp) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs"); @@ -813,7 +813,7 @@ namespace detail frexp(x.z, exp.z)); } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> frexp(vec<4, T, P> const& x, vec<4, int, P>& exp) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs"); @@ -833,7 +833,7 @@ namespace detail return std::ldexp(x, exp); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> ldexp(vec<1, T, P> const& x, vec<1, int, P> const& exp) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs"); @@ -842,7 +842,7 @@ namespace detail ldexp(x.x, exp.x)); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> ldexp(vec<2, T, P> const& x, vec<2, int, P> const& exp) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs"); @@ -852,7 +852,7 @@ namespace detail ldexp(x.y, exp.y)); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> ldexp(vec<3, T, P> const& x, vec<3, int, P> const& exp) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs"); @@ -863,7 +863,7 @@ namespace detail ldexp(x.z, exp.z)); } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> ldexp(vec<4, T, P> const& x, vec<4, int, P> const& exp) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs"); diff --git a/glm/detail/func_common_simd.inl b/glm/detail/func_common_simd.inl index c238e53b..26904757 100644 --- a/glm/detail/func_common_simd.inl +++ b/glm/detail/func_common_simd.inl @@ -10,7 +10,7 @@ namespace glm{ namespace detail { - template + template struct compute_abs_vector<4, float, P, true> { GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v) @@ -21,7 +21,7 @@ namespace detail } }; - template + template struct compute_abs_vector<4, int, P, true> { GLM_FUNC_QUALIFIER static vec<4, int, P> call(vec<4, int, P> const & v) @@ -32,7 +32,7 @@ namespace detail } }; - template + template struct compute_floor<4, float, P, true> { GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v) @@ -43,7 +43,7 @@ namespace detail } }; - template + template struct compute_ceil<4, float, P, true> { GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v) @@ -54,7 +54,7 @@ namespace detail } }; - template + template struct compute_fract<4, float, P, true> { GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v) @@ -65,7 +65,7 @@ namespace detail } }; - template + template struct compute_round<4, float, P, true> { GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v) @@ -76,7 +76,7 @@ namespace detail } }; - template + template struct compute_mod<4, float, P, true> { GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & x, vec<4, float, P> const & y) @@ -87,7 +87,7 @@ namespace detail } }; - template + template struct compute_min_vector<4, float, P, true> { GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v1, vec<4, float, P> const & v2) @@ -98,7 +98,7 @@ namespace detail } }; - template + template struct compute_min_vector<4, int32, P, true> { GLM_FUNC_QUALIFIER static vec<4, int32, P> call(vec<4, int32, P> const & v1, vec<4, int32, P> const & v2) @@ -109,7 +109,7 @@ namespace detail } }; - template + template struct compute_min_vector<4, uint32, P, true> { GLM_FUNC_QUALIFIER static vec<4, int32, P> call(vec<4, uint32, P> const & v1, vec<4, uint32, P> const & v2) @@ -120,7 +120,7 @@ namespace detail } }; - template + template struct compute_max_vector<4, float, P, true> { GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v1, vec<4, float, P> const & v2) @@ -131,7 +131,7 @@ namespace detail } }; - template + template struct compute_max_vector<4, int32, P, true> { GLM_FUNC_QUALIFIER static vec<4, int32, P> call(vec<4, int32, P> const & v1, vec<4, int32, P> const & v2) @@ -142,7 +142,7 @@ namespace detail } }; - template + template struct compute_max_vector<4, uint32, P, true> { GLM_FUNC_QUALIFIER static vec<4, uint32, P> call(vec<4, uint32, P> const & v1, vec<4, uint32, P> const & v2) @@ -153,7 +153,7 @@ namespace detail } }; - template + template struct compute_clamp_vector<4, float, P, true> { GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & x, vec<4, float, P> const & minVal, vec<4, float, P> const & maxVal) @@ -164,7 +164,7 @@ namespace detail } }; - template + template struct compute_clamp_vector<4, int32, P, true> { GLM_FUNC_QUALIFIER static vec<4, int32, P> call(vec<4, int32, P> const & x, vec<4, int32, P> const & minVal, vec<4, int32, P> const & maxVal) @@ -175,7 +175,7 @@ namespace detail } }; - template + template struct compute_clamp_vector<4, uint32, P, true> { GLM_FUNC_QUALIFIER static vec<4, uint32, P> call(vec<4, uint32, P> const & x, vec<4, uint32, P> const & minVal, vec<4, uint32, P> const & maxVal) @@ -186,7 +186,7 @@ namespace detail } }; - template + template struct compute_mix_vector<4, float, bool, P, true> { GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & x, vec<4, float, P> const & y, vec<4, bool, P> const & a) @@ -204,7 +204,7 @@ namespace detail } }; /* FIXME - template + template struct compute_step_vector { GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const& edge, vec<4, float, P> const& x) @@ -215,7 +215,7 @@ namespace detail } }; */ - template + template struct compute_smoothstep_vector<4, float, P, true> { GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const& edge0, vec<4, float, P> const& edge1, vec<4, float, P> const& x) diff --git a/glm/detail/func_exponential.hpp b/glm/detail/func_exponential.hpp index 21b3f735..2f27ea3b 100644 --- a/glm/detail/func_exponential.hpp +++ b/glm/detail/func_exponential.hpp @@ -23,81 +23,81 @@ namespace glm /// Returns 'base' raised to the power 'exponent'. /// - /// @param base Floating point value. pow function is defined for input values of 'base' defined in the range (inf-, inf+) in the limit of the type precision. + /// @param base Floating point value. pow function is defined for input values of 'base' defined in the range (inf-, inf+) in the limit of the type qualifier. /// @param exponent Floating point value representing the 'exponent'. /// /// @see GLSL pow man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions - template + template GLM_FUNC_DECL vec pow(vec const & base, vec const& exponent); /// Returns the natural exponentiation of x, i.e., e^x. /// - /// @param v exp function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type precision. + /// @param v exp function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type qualifier. /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL exp man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions - template + template GLM_FUNC_DECL vec exp(vec const& v); /// Returns the natural logarithm of v, i.e., /// returns the value y which satisfies the equation x = e^y. /// Results are undefined if v <= 0. /// - /// @param v log function is defined for input values of v defined in the range (0, inf+) in the limit of the type precision. + /// @param v log function is defined for input values of v defined in the range (0, inf+) in the limit of the type qualifier. /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL log man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions - template + template GLM_FUNC_DECL vec log(vec const& v); /// Returns 2 raised to the v power. /// - /// @param v exp2 function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type precision. + /// @param v exp2 function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type qualifier. /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL exp2 man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions - template + template GLM_FUNC_DECL vec exp2(vec const& v); /// Returns the base 2 log of x, i.e., returns the value y, /// which satisfies the equation x = 2 ^ y. /// - /// @param v log2 function is defined for input values of v defined in the range (0, inf+) in the limit of the type precision. + /// @param v log2 function is defined for input values of v defined in the range (0, inf+) in the limit of the type qualifier. /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL log2 man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions - template + template GLM_FUNC_DECL vec log2(vec const& v); /// Returns the positive square root of v. /// - /// @param v sqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type precision. + /// @param v sqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type qualifier. /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL sqrt man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions - template + template GLM_FUNC_DECL vec sqrt(vec const & v); /// Returns the reciprocal of the positive square root of v. /// - /// @param v inversesqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type precision. + /// @param v inversesqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type qualifier. /// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector. /// @tparam T Floating-point scalar types. /// /// @see GLSL inversesqrt man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions - template + template GLM_FUNC_DECL vec inversesqrt(vec const & v); /// @} diff --git a/glm/detail/func_exponential.inl b/glm/detail/func_exponential.inl index 0d5fab7b..ce0e10af 100644 --- a/glm/detail/func_exponential.inl +++ b/glm/detail/func_exponential.inl @@ -20,7 +20,7 @@ namespace detail } # endif - template + template struct compute_log2 { GLM_FUNC_QUALIFIER static vec call(vec const& v) @@ -29,7 +29,7 @@ namespace detail } }; - template + template struct compute_sqrt { GLM_FUNC_QUALIFIER static vec call(vec const& x) @@ -38,7 +38,7 @@ namespace detail } }; - template + template struct compute_inversesqrt { GLM_FUNC_QUALIFIER static vec call(vec const & x) @@ -66,7 +66,7 @@ namespace detail // pow using std::pow; - template + template GLM_FUNC_QUALIFIER vec pow(vec const & base, vec const& exponent) { return detail::functor2::call(pow, base, exponent); @@ -74,7 +74,7 @@ namespace detail // exp using std::exp; - template + template GLM_FUNC_QUALIFIER vec exp(vec const& x) { return detail::functor1::call(exp, x); @@ -82,7 +82,7 @@ namespace detail // log using std::log; - template + template GLM_FUNC_QUALIFIER vec log(vec const& x) { return detail::functor1::call(log, x); @@ -97,7 +97,7 @@ namespace detail return std::exp(static_cast(0.69314718055994530941723212145818) * x); } - template + template GLM_FUNC_QUALIFIER vec exp2(vec const& x) { return detail::functor1::call(exp2, x); @@ -110,7 +110,7 @@ namespace detail return log2(vec<1, genType>(x)).x; } - template + template GLM_FUNC_QUALIFIER vec log2(vec const& x) { return detail::compute_log2::is_iec559, detail::is_aligned

::value>::call(x); @@ -118,7 +118,7 @@ namespace detail // sqrt using std::sqrt; - template + template GLM_FUNC_QUALIFIER vec sqrt(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'sqrt' only accept floating-point inputs"); @@ -132,7 +132,7 @@ namespace detail return static_cast(1) / sqrt(x); } - template + template GLM_FUNC_QUALIFIER vec inversesqrt(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'inversesqrt' only accept floating-point inputs"); diff --git a/glm/detail/func_exponential_simd.inl b/glm/detail/func_exponential_simd.inl index b3bdf85a..d2195db5 100644 --- a/glm/detail/func_exponential_simd.inl +++ b/glm/detail/func_exponential_simd.inl @@ -8,7 +8,7 @@ namespace glm{ namespace detail { - template + template struct compute_sqrt<4, float, P, true> { GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v) diff --git a/glm/detail/func_geometric.hpp b/glm/detail/func_geometric.hpp index c10541e0..8ea988e8 100644 --- a/glm/detail/func_geometric.hpp +++ b/glm/detail/func_geometric.hpp @@ -24,7 +24,7 @@ namespace glm /// /// @see GLSL length man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions - template + template GLM_FUNC_DECL T length(vec const& x); /// Returns the distance betwwen p0 and p1, i.e., length(p0 - p1). @@ -34,7 +34,7 @@ namespace glm /// /// @see GLSL distance man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions - template + template GLM_FUNC_DECL T distance(vec const& p0, vec const& p1); /// Returns the dot product of x and y, i.e., result = x * y. @@ -44,7 +44,7 @@ namespace glm /// /// @see GLSL dot man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions - template + template GLM_FUNC_DECL T dot(vec const & x, vec const & y); /// Returns the cross product of x and y. @@ -53,7 +53,7 @@ namespace glm /// /// @see GLSL cross man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions - template + template GLM_FUNC_DECL vec<3, T, P> cross(vec<3, T, P> const & x, vec<3, T, P> const & y); /// Returns a vector in the same direction as x but with length of 1. @@ -64,7 +64,7 @@ namespace glm /// /// @see GLSL normalize man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions - template + template GLM_FUNC_DECL vec normalize(vec const& x); /// If dot(Nref, I) < 0.0, return N, otherwise, return -N. @@ -74,7 +74,7 @@ namespace glm /// /// @see GLSL faceforward man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions - template + template GLM_FUNC_DECL vec faceforward( vec const& N, vec const& I, @@ -88,7 +88,7 @@ namespace glm /// /// @see GLSL reflect man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions - template + template GLM_FUNC_DECL vec reflect( vec const& I, vec const& N); @@ -102,7 +102,7 @@ namespace glm /// /// @see GLSL refract man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions - template + template GLM_FUNC_DECL vec refract( vec const& I, vec const& N, diff --git a/glm/detail/func_geometric.inl b/glm/detail/func_geometric.inl index 3dd31dfe..546ccc06 100644 --- a/glm/detail/func_geometric.inl +++ b/glm/detail/func_geometric.inl @@ -10,7 +10,7 @@ namespace glm{ namespace detail { - template + template struct compute_length { GLM_FUNC_QUALIFIER static T call(vec const& v) @@ -19,7 +19,7 @@ namespace detail } }; - template + template struct compute_distance { GLM_FUNC_QUALIFIER static T call(vec const& p0, vec const& p1) @@ -31,7 +31,7 @@ namespace detail template struct compute_dot{}; - template + template struct compute_dot, T, Aligned> { GLM_FUNC_QUALIFIER static T call(vec<1, T, P> const& a, vec<1, T, P> const& b) @@ -40,7 +40,7 @@ namespace detail } }; - template + template struct compute_dot, T, Aligned> { GLM_FUNC_QUALIFIER static T call(vec<2, T, P> const& a, vec<2, T, P> const& b) @@ -50,7 +50,7 @@ namespace detail } }; - template + template struct compute_dot, T, Aligned> { GLM_FUNC_QUALIFIER static T call(vec<3, T, P> const& a, vec<3, T, P> const& b) @@ -60,7 +60,7 @@ namespace detail } }; - template + template struct compute_dot, T, Aligned> { GLM_FUNC_QUALIFIER static T call(vec<4, T, P> const& a, vec<4, T, P> const& b) @@ -70,7 +70,7 @@ namespace detail } }; - template + template struct compute_cross { GLM_FUNC_QUALIFIER static vec<3, T, P> call(vec<3, T, P> const& x, vec<3, T, P> const& y) @@ -84,7 +84,7 @@ namespace detail } }; - template + template struct compute_normalize { GLM_FUNC_QUALIFIER static vec call(vec const& v) @@ -95,7 +95,7 @@ namespace detail } }; - template + template struct compute_faceforward { GLM_FUNC_QUALIFIER static vec call(vec const& N, vec const& I, vec const& Nref) @@ -106,7 +106,7 @@ namespace detail } }; - template + template struct compute_reflect { GLM_FUNC_QUALIFIER static vec call(vec const& I, vec const& N) @@ -115,7 +115,7 @@ namespace detail } }; - template + template struct compute_refract { GLM_FUNC_QUALIFIER static vec call(vec const& I, vec const& N, T eta) @@ -136,7 +136,7 @@ namespace detail return abs(x); } - template + template GLM_FUNC_QUALIFIER T length(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'length' accepts only floating-point inputs"); @@ -153,7 +153,7 @@ namespace detail return length(p1 - p0); } - template + template GLM_FUNC_QUALIFIER T distance(vec const& p0, vec const& p1) { return detail::compute_distance::value>::call(p0, p1); @@ -167,14 +167,14 @@ namespace detail return x * y; } - template + template GLM_FUNC_QUALIFIER T dot(vec const& x, vec const& y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'dot' accepts only floating-point inputs"); return detail::compute_dot, T, detail::is_aligned

::value>::call(x, y); } - template + template GLM_FUNC_QUALIFIER T dot(tquat const& x, tquat const& y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'dot' accepts only floating-point inputs"); @@ -182,7 +182,7 @@ namespace detail } // cross - template + template GLM_FUNC_QUALIFIER vec<3, T, P> cross(vec<3, T, P> const& x, vec<3, T, P> const& y) { return detail::compute_cross::value>::call(x, y); @@ -197,7 +197,7 @@ namespace detail return x < genType(0) ? genType(-1) : genType(1); } - template + template GLM_FUNC_QUALIFIER vec normalize(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'normalize' accepts only floating-point inputs"); @@ -212,7 +212,7 @@ namespace detail return dot(Nref, I) < static_cast(0) ? N : -N; } - template + template GLM_FUNC_QUALIFIER vec faceforward(vec const& N, vec const& I, vec const& Nref) { return detail::compute_faceforward::value>::call(N, I, Nref); @@ -225,7 +225,7 @@ namespace detail return I - N * dot(N, I) * genType(2); } - template + template GLM_FUNC_QUALIFIER vec reflect(vec const& I, vec const& N) { return detail::compute_reflect::value>::call(I, N); @@ -241,7 +241,7 @@ namespace detail return (eta * I - (eta * dotValue + sqrt(k)) * N) * static_cast(k >= static_cast(0)); } - template + template GLM_FUNC_QUALIFIER vec refract(vec const& I, vec const& N, T eta) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'refract' accepts only floating-point inputs"); diff --git a/glm/detail/func_geometric_simd.inl b/glm/detail/func_geometric_simd.inl index 55a0f2d4..8e6026ac 100644 --- a/glm/detail/func_geometric_simd.inl +++ b/glm/detail/func_geometric_simd.inl @@ -8,7 +8,7 @@ namespace glm{ namespace detail { - template + template struct compute_length<4, float, P, true> { GLM_FUNC_QUALIFIER static float call(vec<4, float, P> const & v) @@ -17,7 +17,7 @@ namespace detail } }; - template + template struct compute_distance<4, float, P, true> { GLM_FUNC_QUALIFIER static float call(vec<4, float, P> const & p0, vec<4, float, P> const & p1) @@ -26,7 +26,7 @@ namespace detail } }; - template + template struct compute_dot, float, true> { GLM_FUNC_QUALIFIER static float call(vec<4, float, P> const& x, vec<4, float, P> const& y) @@ -35,7 +35,7 @@ namespace detail } }; - template + template struct compute_cross { GLM_FUNC_QUALIFIER static vec<3, float, P> call(vec<3, float, P> const & a, vec<3, float, P> const & b) @@ -50,7 +50,7 @@ namespace detail } }; - template + template struct compute_normalize<4, float, P, true> { GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v) @@ -61,7 +61,7 @@ namespace detail } }; - template + template struct compute_faceforward<4, float, P, true> { GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const& N, vec<4, float, P> const& I, vec<4, float, P> const& Nref) @@ -72,7 +72,7 @@ namespace detail } }; - template + template struct compute_reflect<4, float, P, true> { GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const& I, vec<4, float, P> const& N) @@ -83,7 +83,7 @@ namespace detail } }; - template + template struct compute_refract<4, float, P, true> { GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const& I, vec<4, float, P> const& N, float eta) diff --git a/glm/detail/func_integer.hpp b/glm/detail/func_integer.hpp index 1886e2f4..3c9eaf87 100644 --- a/glm/detail/func_integer.hpp +++ b/glm/detail/func_integer.hpp @@ -13,7 +13,7 @@ #pragma once #include "setup.hpp" -#include "precision.hpp" +#include "qualifier.hpp" #include "func_common.hpp" #include "func_vector_relational.hpp" @@ -30,7 +30,7 @@ namespace glm /// /// @see GLSL uaddCarry man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions - template + template GLM_FUNC_DECL vec uaddCarry( vec const & x, vec const & y, @@ -44,7 +44,7 @@ namespace glm /// /// @see GLSL usubBorrow man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions - template + template GLM_FUNC_DECL vec usubBorrow( vec const & x, vec const & y, @@ -58,7 +58,7 @@ namespace glm /// /// @see GLSL umulExtended man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions - template + template GLM_FUNC_DECL void umulExtended( vec const & x, vec const & y, @@ -73,7 +73,7 @@ namespace glm /// /// @see GLSL imulExtended man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions - template + template GLM_FUNC_DECL void imulExtended( vec const & x, vec const & y, @@ -96,7 +96,7 @@ namespace glm /// /// @see GLSL bitfieldExtract man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions - template + template GLM_FUNC_DECL vec bitfieldExtract( vec const& Value, int Offset, @@ -117,7 +117,7 @@ namespace glm /// /// @see GLSL bitfieldInsert man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions - template + template GLM_FUNC_DECL vec bitfieldInsert( vec const& Base, vec const& Insert, @@ -133,7 +133,7 @@ namespace glm /// /// @see GLSL bitfieldReverse man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions - template + template GLM_FUNC_DECL vec bitfieldReverse(vec const & v); /// Returns the number of bits set to 1 in the binary representation of value. @@ -152,7 +152,7 @@ namespace glm /// /// @see GLSL bitCount man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions - template + template GLM_FUNC_DECL vec bitCount(vec const & v); /// Returns the bit number of the least significant bit set to @@ -175,7 +175,7 @@ namespace glm /// /// @see GLSL findLSB man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions - template + template GLM_FUNC_DECL vec findLSB(vec const & v); /// Returns the bit number of the most significant bit in the binary representation of value. @@ -200,7 +200,7 @@ namespace glm /// /// @see GLSL findMSB man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions - template + template GLM_FUNC_DECL vec findMSB(vec const & v); /// @} diff --git a/glm/detail/func_integer.inl b/glm/detail/func_integer.inl index 6421f689..3d462c89 100644 --- a/glm/detail/func_integer.inl +++ b/glm/detail/func_integer.inl @@ -30,7 +30,7 @@ namespace detail return Bits >= static_cast(sizeof(T) * 8) ? ~static_cast(0) : (static_cast(1) << Bits) - static_cast(1); } - template + template struct compute_bitfieldReverseStep { GLM_FUNC_QUALIFIER static vec call(vec const& v, T, T) @@ -39,7 +39,7 @@ namespace detail } }; - template + template struct compute_bitfieldReverseStep { GLM_FUNC_QUALIFIER static vec call(vec const& v, T Mask, T Shift) @@ -48,7 +48,7 @@ namespace detail } }; - template + template struct compute_bitfieldBitCountStep { GLM_FUNC_QUALIFIER static vec call(vec const& v, T, T) @@ -57,7 +57,7 @@ namespace detail } }; - template + template struct compute_bitfieldBitCountStep { GLM_FUNC_QUALIFIER static vec call(vec const& v, T Mask, T Shift) @@ -104,7 +104,7 @@ namespace detail # endif # endif//GLM_HAS_BITSCAN_WINDOWS - template + template struct compute_findMSB_step_vec { GLM_FUNC_QUALIFIER static vec call(vec const& x, T Shift) @@ -113,7 +113,7 @@ namespace detail } }; - template + template struct compute_findMSB_step_vec { GLM_FUNC_QUALIFIER static vec call(vec const& x, T) @@ -122,7 +122,7 @@ namespace detail } }; - template + template struct compute_findMSB_vec { GLM_FUNC_QUALIFIER static vec call(vec const& v) @@ -147,7 +147,7 @@ namespace detail return IsNotNull ? int(Result) : -1; } - template + template struct compute_findMSB_vec { GLM_FUNC_QUALIFIER static vec call(vec const& x) @@ -165,7 +165,7 @@ namespace detail return IsNotNull ? int(Result) : -1; } - template + template struct compute_findMSB_vec { GLM_FUNC_QUALIFIER static vec call(vec const& x) @@ -186,7 +186,7 @@ namespace detail return static_cast(Value64 % (Max32 + static_cast(1))); } - template + template GLM_FUNC_QUALIFIER vec uaddCarry(vec const& x, vec const& y, vec& Carry) { vec Value64(vec(x) + vec(y)); @@ -207,7 +207,7 @@ namespace detail return static_cast((static_cast(1) << static_cast(32)) + (static_cast(y) - static_cast(x))); } - template + template GLM_FUNC_QUALIFIER vec usubBorrow(vec const& x, vec const& y, vec& Borrow) { Borrow = mix(vec(1), vec(0), greaterThanEqual(x, y)); @@ -226,7 +226,7 @@ namespace detail lsb = static_cast(Value64); } - template + template GLM_FUNC_QUALIFIER void umulExtended(vec const& x, vec const& y, vec& msb, vec& lsb) { GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch"); @@ -246,7 +246,7 @@ namespace detail lsb = static_cast(Value64); } - template + template GLM_FUNC_QUALIFIER void imulExtended(vec const& x, vec const& y, vec& msb, vec& lsb) { GLM_STATIC_ASSERT(sizeof(int) == sizeof(int32), "int and int32 size mismatch"); @@ -263,7 +263,7 @@ namespace detail return bitfieldExtract(vec<1, genIUType>(Value), Offset, Bits).x; } - template + template GLM_FUNC_QUALIFIER vec bitfieldExtract(vec const& Value, int Offset, int Bits) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldExtract' only accept integer inputs"); @@ -278,7 +278,7 @@ namespace detail return bitfieldInsert(vec<1, genIUType>(Base), vec<1, genIUType>(Insert), Offset, Bits).x; } - template + template GLM_FUNC_QUALIFIER vec bitfieldInsert(vec const& Base, vec const& Insert, int Offset, int Bits) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldInsert' only accept integer values"); @@ -294,7 +294,7 @@ namespace detail return bitfieldReverse(glm::vec<1, genType, glm::defaultp>(x)).x; } - template + template GLM_FUNC_QUALIFIER vec bitfieldReverse(vec const& v) { vec x(v); @@ -314,7 +314,7 @@ namespace detail return bitCount(glm::vec<1, genType, glm::defaultp>(x)).x; } - template + template GLM_FUNC_QUALIFIER vec bitCount(vec const& v) { # if GLM_COMPILER & GLM_COMPILER_VC @@ -345,7 +345,7 @@ namespace detail return detail::compute_findLSB::call(Value); } - template + template GLM_FUNC_QUALIFIER vec findLSB(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findLSB' only accept integer values"); @@ -362,7 +362,7 @@ namespace detail return findMSB(vec<1, genIUType>(v)).x; } - template + template GLM_FUNC_QUALIFIER vec findMSB(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'findMSB' only accept integer values"); diff --git a/glm/detail/func_integer_simd.inl b/glm/detail/func_integer_simd.inl index addff798..a31a57b8 100644 --- a/glm/detail/func_integer_simd.inl +++ b/glm/detail/func_integer_simd.inl @@ -8,7 +8,7 @@ namespace glm{ namespace detail { - template + template struct compute_bitfieldReverseStep<4, uint32, P, true, true> { GLM_FUNC_QUALIFIER static vec<4, uint32, P> call(vec<4, uint32, P> const& v, uint32 Mask, uint32 Shift) @@ -29,7 +29,7 @@ namespace detail } }; - template + template struct compute_bitfieldBitCountStep<4, uint32, P, true, true> { GLM_FUNC_QUALIFIER static vec<4, uint32, P> call(vec<4, uint32, P> const& v, uint32 Mask, uint32 Shift) diff --git a/glm/detail/func_matrix.hpp b/glm/detail/func_matrix.hpp index faae29f7..c3ee1b0d 100644 --- a/glm/detail/func_matrix.hpp +++ b/glm/detail/func_matrix.hpp @@ -7,15 +7,15 @@ /// @ingroup core /// /// For each of the following built-in matrix functions, there is both a -/// single-precision floating point version, where all arguments and return values -/// are single precision, and a double-precision floating version, where all -/// arguments and return values are double precision. Only the single-precision +/// single-qualifier floating point version, where all arguments and return values +/// are single qualifier, and a double-qualifier floating version, where all +/// arguments and return values are double qualifier. Only the single-qualifier /// floating point version is shown. #pragma once // Dependencies -#include "../detail/precision.hpp" +#include "../detail/qualifier.hpp" #include "../detail/setup.hpp" #include "../detail/type_mat.hpp" #include "../vec2.hpp" @@ -34,55 +34,55 @@ namespace glm{ namespace detail { - template + template struct outerProduct_trait<2, 2, T, P> { typedef mat<2, 2, T, P> type; }; - template + template struct outerProduct_trait<2, 3, T, P> { typedef mat<3, 2, T, P> type; }; - template + template struct outerProduct_trait<2, 4, T, P> { typedef mat<4, 2, T, P> type; }; - template + template struct outerProduct_trait<3, 2, T, P> { typedef mat<2, 3, T, P> type; }; - template + template struct outerProduct_trait<3, 3, T, P> { typedef mat<3, 3, T, P> type; }; - template + template struct outerProduct_trait<3, 4, T, P> { typedef mat<4, 3, T, P> type; }; - template + template struct outerProduct_trait<4, 2, T, P> { typedef mat<2, 4, T, P> type; }; - template + template struct outerProduct_trait<4, 3, T, P> { typedef mat<3, 4, T, P> type; }; - template + template struct outerProduct_trait<4, 4, T, P> { typedef mat<4, 4, T, P> type; @@ -100,7 +100,7 @@ namespace detail /// /// @see GLSL matrixCompMult man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions - template class matType> + template class matType> GLM_FUNC_DECL matType matrixCompMult(matType const & x, matType const & y); /// Treats the first parameter c as a column vector @@ -109,7 +109,7 @@ namespace detail /// /// @see GLSL outerProduct man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions - template + template GLM_FUNC_DECL typename detail::outerProduct_trait::type outerProduct(vec const & c, vec const & r); /// Returns the transposed matrix of x @@ -118,7 +118,7 @@ namespace detail /// /// @see GLSL transpose man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions - template class matType> + template class matType> GLM_FUNC_DECL typename matType::transpose_type transpose(matType const & x); /// Return the determinant of a squared matrix. @@ -127,7 +127,7 @@ namespace detail /// /// @see GLSL determinant man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions - template class matType> + template class matType> GLM_FUNC_DECL T determinant(matType const & m); /// Return the inverse of a squared matrix. @@ -136,7 +136,7 @@ namespace detail /// /// @see GLSL inverse man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions - template class matType> + template class matType> GLM_FUNC_DECL matType inverse(matType const & m); /// @} diff --git a/glm/detail/func_matrix.inl b/glm/detail/func_matrix.inl index bb93d02d..d99ad871 100644 --- a/glm/detail/func_matrix.inl +++ b/glm/detail/func_matrix.inl @@ -7,7 +7,7 @@ namespace glm{ namespace detail { - template class matType, length_t C, length_t R, typename T, precision P, bool Aligned> + template class matType, length_t C, length_t R, typename T, qualifier P, bool Aligned> struct compute_matrixCompMult { GLM_FUNC_QUALIFIER static matType call(matType const& x, matType const& y) @@ -19,10 +19,10 @@ namespace detail } }; - template class matType, length_t C, length_t R, typename T, precision P, bool Aligned> + template class matType, length_t C, length_t R, typename T, qualifier P, bool Aligned> struct compute_transpose{}; - template + template struct compute_transpose { GLM_FUNC_QUALIFIER static mat<2, 2, T, P> call(mat<2, 2, T, P> const& m) @@ -36,7 +36,7 @@ namespace detail } }; - template + template struct compute_transpose { GLM_FUNC_QUALIFIER static mat<3, 2, T, P> call(mat<2, 3, T, P> const& m) @@ -52,7 +52,7 @@ namespace detail } }; - template + template struct compute_transpose { GLM_FUNC_QUALIFIER static mat<4, 2, T, P> call(mat<2, 4, T, P> const& m) @@ -70,7 +70,7 @@ namespace detail } }; - template + template struct compute_transpose { GLM_FUNC_QUALIFIER static mat<2, 3, T, P> call(mat<3, 2, T, P> const& m) @@ -86,7 +86,7 @@ namespace detail } }; - template + template struct compute_transpose { GLM_FUNC_QUALIFIER static mat<3, 3, T, P> call(mat<3, 3, T, P> const& m) @@ -107,7 +107,7 @@ namespace detail } }; - template + template struct compute_transpose { GLM_FUNC_QUALIFIER static mat<4, 3, T, P> call(mat<3, 4, T, P> const& m) @@ -129,7 +129,7 @@ namespace detail } }; - template + template struct compute_transpose { GLM_FUNC_QUALIFIER static mat<2, 4, T, P> call(mat<4, 2, T, P> const& m) @@ -147,7 +147,7 @@ namespace detail } }; - template + template struct compute_transpose { GLM_FUNC_QUALIFIER static mat<3, 4, T, P> call(mat<4, 3, T, P> const& m) @@ -169,7 +169,7 @@ namespace detail } }; - template + template struct compute_transpose { GLM_FUNC_QUALIFIER static mat<4, 4, T, P> call(mat<4, 4, T, P> const& m) @@ -198,10 +198,10 @@ namespace detail } }; - template class matType, length_t C, length_t R, typename T, precision P, bool Aligned> + template class matType, length_t C, length_t R, typename T, qualifier P, bool Aligned> struct compute_determinant{}; - template + template struct compute_determinant { GLM_FUNC_QUALIFIER static T call(mat<2, 2, T, P> const& m) @@ -210,7 +210,7 @@ namespace detail } }; - template + template struct compute_determinant { GLM_FUNC_QUALIFIER static T call(mat<3, 3, T, P> const& m) @@ -222,7 +222,7 @@ namespace detail } }; - template + template struct compute_determinant { GLM_FUNC_QUALIFIER static T call(mat<4, 4, T, P> const& m) @@ -246,10 +246,10 @@ namespace detail } }; - template class matType, length_t C, length_t R, typename T, precision P, bool Aligned> + template class matType, length_t C, length_t R, typename T, qualifier P, bool Aligned> struct compute_inverse{}; - template + template struct compute_inverse { GLM_FUNC_QUALIFIER static mat<2, 2, T, P> call(mat<2, 2, T, P> const& m) @@ -268,7 +268,7 @@ namespace detail } }; - template + template struct compute_inverse { GLM_FUNC_QUALIFIER static mat<3, 3, T, P> call(mat<3, 3, T, P> const& m) @@ -293,7 +293,7 @@ namespace detail } }; - template + template struct compute_inverse { GLM_FUNC_QUALIFIER static mat<4, 4, T, P> call(mat<4, 4, T, P> const& m) @@ -355,14 +355,14 @@ namespace detail }; }//namespace detail - template class matType> + template class matType> GLM_FUNC_QUALIFIER matType matrixCompMult(matType const & x, matType const & y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'matrixCompMult' only accept floating-point inputs"); return detail::compute_matrixCompMult::value>::call(x, y); } - template + template GLM_FUNC_QUALIFIER typename detail::outerProduct_trait::type outerProduct(vec const & c, vec const & r) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'outerProduct' only accept floating-point inputs"); @@ -373,21 +373,21 @@ namespace detail return m; } - template class matType> + template class matType> GLM_FUNC_QUALIFIER typename matType::transpose_type transpose(matType const & m) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'transpose' only accept floating-point inputs"); return detail::compute_transpose::value>::call(m); } - template class matType> + template class matType> GLM_FUNC_QUALIFIER T determinant(matType const & m) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'determinant' only accept floating-point inputs"); return detail::compute_determinant::value>::call(m); } - template class matType> + template class matType> GLM_FUNC_QUALIFIER matType inverse(matType const & m) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'inverse' only accept floating-point inputs"); diff --git a/glm/detail/func_matrix_simd.inl b/glm/detail/func_matrix_simd.inl index 2e20b80a..48455e90 100644 --- a/glm/detail/func_matrix_simd.inl +++ b/glm/detail/func_matrix_simd.inl @@ -11,7 +11,7 @@ namespace glm{ namespace detail { - template + template struct compute_matrixCompMult { GLM_STATIC_ASSERT(detail::is_aligned

::value, "Specialization requires aligned"); @@ -27,7 +27,7 @@ namespace detail } }; - template + template struct compute_transpose { GLM_FUNC_QUALIFIER static mat<4, 4, float, P> call(mat<4, 4, float, P> const & m) @@ -40,7 +40,7 @@ namespace detail } }; - template + template struct compute_determinant { GLM_FUNC_QUALIFIER static float call(mat<4, 4, float, P> const& m) @@ -49,7 +49,7 @@ namespace detail } }; - template + template struct compute_inverse { GLM_FUNC_QUALIFIER static mat<4, 4, float, P> call(mat<4, 4, float, P> const& m) diff --git a/glm/detail/func_packing.hpp b/glm/detail/func_packing.hpp index 47e074b4..e623b557 100644 --- a/glm/detail/func_packing.hpp +++ b/glm/detail/func_packing.hpp @@ -123,7 +123,7 @@ namespace glm /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions GLM_FUNC_DECL vec4 unpackSnorm4x8(uint p); - /// Returns a double-precision value obtained by packing the components of v into a 64-bit value. + /// Returns a double-qualifier value obtained by packing the components of v into a 64-bit value. /// If an IEEE 754 Inf or NaN is created, it will not signal, and the resulting floating point value is unspecified. /// Otherwise, the bit- level representation of v is preserved. /// The first vector component specifies the 32 least significant bits; diff --git a/glm/detail/func_trigonometric.hpp b/glm/detail/func_trigonometric.hpp index 1eb4d786..8a6d0747 100644 --- a/glm/detail/func_trigonometric.hpp +++ b/glm/detail/func_trigonometric.hpp @@ -15,7 +15,7 @@ #pragma once #include "setup.hpp" -#include "precision.hpp" +#include "qualifier.hpp" namespace glm { @@ -26,22 +26,22 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Enumeration value precision + /// @tparam P Enumeration value qualifier /// /// @see GLSL radians man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions - template + template GLM_FUNC_DECL GLM_CONSTEXPR vec radians(vec const& degrees); /// Converts radians to degrees and returns the result. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Enumeration value precision + /// @tparam P Enumeration value qualifier /// /// @see GLSL degrees man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions - template + template GLM_FUNC_DECL GLM_CONSTEXPR vec degrees(vec const& radians); /// The standard trigonometric sine function. @@ -49,11 +49,11 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Enumeration value precision + /// @tparam P Enumeration value qualifier /// /// @see GLSL sin man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions - template + template GLM_FUNC_DECL vec sin(vec const& angle); /// The standard trigonometric cosine function. @@ -61,22 +61,22 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Enumeration value precision + /// @tparam P Enumeration value qualifier /// /// @see GLSL cos man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions - template + template GLM_FUNC_DECL vec cos(vec const& angle); /// The standard trigonometric tangent function. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Enumeration value precision + /// @tparam P Enumeration value qualifier /// /// @see GLSL tan man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions - template + template GLM_FUNC_DECL vec tan(vec const& angle); /// Arc sine. Returns an angle whose sine is x. @@ -85,11 +85,11 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Enumeration value precision + /// @tparam P Enumeration value qualifier /// /// @see GLSL asin man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions - template + template GLM_FUNC_DECL vec asin(vec const& x); /// Arc cosine. Returns an angle whose sine is x. @@ -98,11 +98,11 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Enumeration value precision + /// @tparam P Enumeration value qualifier /// /// @see GLSL acos man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions - template + template GLM_FUNC_DECL vec acos(vec const& x); /// Arc tangent. Returns an angle whose tangent is y/x. @@ -113,11 +113,11 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Enumeration value precision + /// @tparam P Enumeration value qualifier /// /// @see GLSL atan man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions - template + template GLM_FUNC_DECL vec atan(vec const& y, vec const& x); /// Arc tangent. Returns an angle whose tangent is y_over_x. @@ -125,55 +125,55 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Enumeration value precision + /// @tparam P Enumeration value qualifier /// /// @see GLSL atan man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions - template + template GLM_FUNC_DECL vec atan(vec const& y_over_x); /// Returns the hyperbolic sine function, (exp(x) - exp(-x)) / 2 /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Enumeration value precision + /// @tparam P Enumeration value qualifier /// /// @see GLSL sinh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions - template + template GLM_FUNC_DECL vec sinh(vec const& angle); /// Returns the hyperbolic cosine function, (exp(x) + exp(-x)) / 2 /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Enumeration value precision + /// @tparam P Enumeration value qualifier /// /// @see GLSL cosh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions - template + template GLM_FUNC_DECL vec cosh(vec const& angle); /// Returns the hyperbolic tangent function, sinh(angle) / cosh(angle) /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Enumeration value precision + /// @tparam P Enumeration value qualifier /// /// @see GLSL tanh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions - template + template GLM_FUNC_DECL vec tanh(vec const& angle); /// Arc hyperbolic sine; returns the inverse of sinh. /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Enumeration value precision + /// @tparam P Enumeration value qualifier /// /// @see GLSL asinh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions - template + template GLM_FUNC_DECL vec asinh(vec const& x); /// Arc hyperbolic cosine; returns the non-negative inverse @@ -181,11 +181,11 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Enumeration value precision + /// @tparam P Enumeration value qualifier /// /// @see GLSL acosh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions - template + template GLM_FUNC_DECL vec acosh(vec const& x); /// Arc hyperbolic tangent; returns the inverse of tanh. @@ -193,11 +193,11 @@ namespace glm /// /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam T Floating-point scalar types - /// @tparam P Enumeration value precision + /// @tparam P Enumeration value qualifier /// /// @see GLSL atanh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions - template + template GLM_FUNC_DECL vec atanh(vec const& x); /// @} diff --git a/glm/detail/func_trigonometric.inl b/glm/detail/func_trigonometric.inl index 460b98de..a1ac2f11 100644 --- a/glm/detail/func_trigonometric.inl +++ b/glm/detail/func_trigonometric.inl @@ -16,7 +16,7 @@ namespace glm return degrees * static_cast(0.01745329251994329576923690768489); } - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec radians(vec const& v) { return detail::functor1::call(radians, v); @@ -31,7 +31,7 @@ namespace glm return radians * static_cast(57.295779513082320876798154814105); } - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec degrees(vec const& v) { return detail::functor1::call(degrees, v); @@ -40,7 +40,7 @@ namespace glm // sin using ::std::sin; - template + template GLM_FUNC_QUALIFIER vec sin(vec const& v) { return detail::functor1::call(sin, v); @@ -49,7 +49,7 @@ namespace glm // cos using std::cos; - template + template GLM_FUNC_QUALIFIER vec cos(vec const& v) { return detail::functor1::call(cos, v); @@ -58,7 +58,7 @@ namespace glm // tan using std::tan; - template + template GLM_FUNC_QUALIFIER vec tan(vec const& v) { return detail::functor1::call(tan, v); @@ -67,7 +67,7 @@ namespace glm // asin using std::asin; - template + template GLM_FUNC_QUALIFIER vec asin(vec const& v) { return detail::functor1::call(asin, v); @@ -76,7 +76,7 @@ namespace glm // acos using std::acos; - template + template GLM_FUNC_QUALIFIER vec acos(vec const& v) { return detail::functor1::call(acos, v); @@ -91,7 +91,7 @@ namespace glm return ::std::atan2(y, x); } - template + template GLM_FUNC_QUALIFIER vec atan(vec const& a, vec const& b) { return detail::functor2::call(::std::atan2, a, b); @@ -99,7 +99,7 @@ namespace glm using std::atan; - template + template GLM_FUNC_QUALIFIER vec atan(vec const& v) { return detail::functor1::call(atan, v); @@ -108,7 +108,7 @@ namespace glm // sinh using std::sinh; - template + template GLM_FUNC_QUALIFIER vec sinh(vec const& v) { return detail::functor1::call(sinh, v); @@ -117,7 +117,7 @@ namespace glm // cosh using std::cosh; - template + template GLM_FUNC_QUALIFIER vec cosh(vec const& v) { return detail::functor1::call(cosh, v); @@ -126,7 +126,7 @@ namespace glm // tanh using std::tanh; - template + template GLM_FUNC_QUALIFIER vec tanh(vec const& v) { return detail::functor1::call(tanh, v); @@ -145,7 +145,7 @@ namespace glm } # endif - template + template GLM_FUNC_QUALIFIER vec asinh(vec const& v) { return detail::functor1::call(asinh, v); @@ -166,7 +166,7 @@ namespace glm } # endif - template + template GLM_FUNC_QUALIFIER vec acosh(vec const& v) { return detail::functor1::call(acosh, v); @@ -187,7 +187,7 @@ namespace glm } # endif - template + template GLM_FUNC_QUALIFIER vec atanh(vec const& v) { return detail::functor1::call(atanh, v); diff --git a/glm/detail/func_vector_relational.hpp b/glm/detail/func_vector_relational.hpp index 8afb6d23..0e463113 100644 --- a/glm/detail/func_vector_relational.hpp +++ b/glm/detail/func_vector_relational.hpp @@ -15,7 +15,7 @@ #pragma once -#include "precision.hpp" +#include "qualifier.hpp" #include "setup.hpp" namespace glm @@ -30,7 +30,7 @@ namespace glm /// /// @see GLSL lessThan man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions - template + template GLM_FUNC_DECL vec lessThan(vec const& x, vec const& y); /// Returns the component-wise comparison of result x <= y. @@ -40,7 +40,7 @@ namespace glm /// /// @see GLSL lessThanEqual man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions - template + template GLM_FUNC_DECL vec lessThanEqual(vec const& x, vec const& y); /// Returns the component-wise comparison of result x > y. @@ -50,7 +50,7 @@ namespace glm /// /// @see GLSL greaterThan man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions - template + template GLM_FUNC_DECL vec greaterThan(vec const& x, vec const& y); /// Returns the component-wise comparison of result x >= y. @@ -60,7 +60,7 @@ namespace glm /// /// @see GLSL greaterThanEqual man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions - template + template GLM_FUNC_DECL vec greaterThanEqual(vec const& x, vec const& y); /// Returns the component-wise comparison of result x == y. @@ -70,7 +70,7 @@ namespace glm /// /// @see GLSL equal man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions - template + template GLM_FUNC_DECL vec equal(vec const& x, vec const& y); /// Returns the component-wise comparison of result x != y. @@ -80,7 +80,7 @@ namespace glm /// /// @see GLSL notEqual man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions - template + template GLM_FUNC_DECL vec notEqual(vec const& x, vec const& y); /// Returns true if any component of x is true. @@ -89,7 +89,7 @@ namespace glm /// /// @see GLSL any man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions - template + template GLM_FUNC_DECL bool any(vec const& v); /// Returns true if all components of x are true. @@ -98,7 +98,7 @@ namespace glm /// /// @see GLSL all man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions - template + template GLM_FUNC_DECL bool all(vec const& v); /// Returns the component-wise logical complement of x. @@ -108,7 +108,7 @@ namespace glm /// /// @see GLSL not man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions - template + template GLM_FUNC_DECL vec not_(vec const& v); /// @} diff --git a/glm/detail/func_vector_relational.inl b/glm/detail/func_vector_relational.inl index d3a30590..f7131a16 100644 --- a/glm/detail/func_vector_relational.inl +++ b/glm/detail/func_vector_relational.inl @@ -5,7 +5,7 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER vec lessThan(vec const& x, vec const& y) { assert(x.length() == y.length()); @@ -17,7 +17,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER vec lessThanEqual(vec const& x, vec const& y) { assert(x.length() == y.length()); @@ -28,7 +28,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER vec greaterThan(vec const& x, vec const& y) { assert(x.length() == y.length()); @@ -39,7 +39,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER vec greaterThanEqual(vec const& x, vec const& y) { assert(x.length() == y.length()); @@ -50,7 +50,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER vec equal(vec const& x, vec const& y) { assert(x.length() == y.length()); @@ -61,7 +61,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER vec notEqual(vec const& x, vec const& y) { assert(x.length() == y.length()); @@ -72,7 +72,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER bool any(vec const& v) { bool Result = false; @@ -81,7 +81,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER bool all(vec const& v) { bool Result = true; @@ -90,7 +90,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER vec not_(vec const& v) { vec Result; diff --git a/glm/detail/qualifier.hpp b/glm/detail/qualifier.hpp index d6a3f082..a6edeb1e 100644 --- a/glm/detail/qualifier.hpp +++ b/glm/detail/qualifier.hpp @@ -1,5 +1,5 @@ /// @ref core -/// @file glm/detail/precision.hpp +/// @file glm/detail/qualifier.hpp #pragma once @@ -7,8 +7,8 @@ namespace glm { - /// enum precision - enum precision + /// Qualify GLM types in term of alignment (packed, aligned) and precision in term of ULPs (lowp, mediump, highp) + enum qualifier { packed_highp, packed_mediump, @@ -33,12 +33,12 @@ namespace glm # endif }; - template struct vec; - template struct mat; + template struct vec; + template struct mat; namespace detail { - template + template struct is_aligned { static const bool value = false; diff --git a/glm/detail/type_float.hpp b/glm/detail/type_float.hpp index 900a3fbc..cf4e60a8 100644 --- a/glm/detail/type_float.hpp +++ b/glm/detail/type_float.hpp @@ -19,22 +19,22 @@ namespace detail /// @addtogroup core_precision /// @{ - /// Low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// Low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.4 Floats /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef lowp_float_t lowp_float; - /// Medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// Medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.4 Floats /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mediump_float_t mediump_float; - /// High precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// High qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.4 Floats /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier diff --git a/glm/detail/type_int.hpp b/glm/detail/type_int.hpp index 36feb16a..9e1471d5 100644 --- a/glm/detail/type_int.hpp +++ b/glm/detail/type_int.hpp @@ -216,43 +216,43 @@ namespace detail /// @addtogroup core_precision /// @{ - /// Low precision signed integer. - /// There is no guarantee on the actual precision. + /// Low qualifier signed integer. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.3 Integers /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef detail::lowp_int_t lowp_int; - /// Medium precision signed integer. - /// There is no guarantee on the actual precision. + /// Medium qualifier signed integer. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.3 Integers /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef detail::mediump_int_t mediump_int; - /// High precision signed integer. - /// There is no guarantee on the actual precision. + /// High qualifier signed integer. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.3 Integers /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef detail::highp_int_t highp_int; - /// Low precision unsigned integer. - /// There is no guarantee on the actual precision. + /// Low qualifier unsigned integer. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.3 Integers /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef detail::lowp_uint_t lowp_uint; - /// Medium precision unsigned integer. - /// There is no guarantee on the actual precision. + /// Medium qualifier unsigned integer. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.3 Integers /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef detail::mediump_uint_t mediump_uint; - /// High precision unsigned integer. - /// There is no guarantee on the actual precision. + /// High qualifier unsigned integer. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.3 Integers /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier diff --git a/glm/detail/type_mat.hpp b/glm/detail/type_mat.hpp index 8cb2afbb..c07d1587 100644 --- a/glm/detail/type_mat.hpp +++ b/glm/detail/type_mat.hpp @@ -3,70 +3,70 @@ #pragma once -#include "precision.hpp" +#include "qualifier.hpp" namespace glm{ namespace detail { - template + template struct outerProduct_trait{}; }//namespace detail #if GLM_HAS_TEMPLATE_ALIASES - template using tmat2x2 = mat<2, 2, T, P>; - template using tmat2x3 = mat<2, 3, T, P>; - template using tmat2x4 = mat<2, 4, T, P>; - template using tmat3x2 = mat<3, 2, T, P>; - template using tmat3x3 = mat<3, 3, T, P>; - template using tmat3x4 = mat<3, 4, T, P>; - template using tmat4x2 = mat<4, 2, T, P>; - template using tmat4x3 = mat<4, 3, T, P>; - template using tmat4x4 = mat<4, 4, T, P>; + template using tmat2x2 = mat<2, 2, T, P>; + template using tmat2x3 = mat<2, 3, T, P>; + template using tmat2x4 = mat<2, 4, T, P>; + template using tmat3x2 = mat<3, 2, T, P>; + template using tmat3x3 = mat<3, 3, T, P>; + template using tmat3x4 = mat<3, 4, T, P>; + template using tmat4x2 = mat<4, 2, T, P>; + template using tmat4x3 = mat<4, 3, T, P>; + template using tmat4x4 = mat<4, 4, T, P>; #endif//GLM_HAS_TEMPLATE_ALIASES - template class matType> + template class matType> GLM_FUNC_DECL matType inverse(matType const & m); /// @addtogroup core_precision /// @{ - /// 2 columns of 2 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 2 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, lowp> lowp_mat2; - /// 2 columns of 2 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 2 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, mediump> mediump_mat2; - /// 2 columns of 2 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 2 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, highp> highp_mat2; - /// 2 columns of 2 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 2 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, lowp> lowp_mat2x2; - /// 2 columns of 2 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 2 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, mediump> mediump_mat2x2; - /// 2 columns of 2 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 2 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier @@ -77,22 +77,22 @@ namespace detail /// @addtogroup core_precision /// @{ - /// 2 columns of 3 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 3 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 3, float, lowp> lowp_mat2x3; - /// 2 columns of 3 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 3 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 3, float, mediump> mediump_mat2x3; - /// 2 columns of 3 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 3 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier @@ -103,22 +103,22 @@ namespace detail /// @addtogroup core_precision /// @{ - /// 2 columns of 4 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 4 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 4, float, lowp> lowp_mat2x4; - /// 2 columns of 4 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 4 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 4, float, mediump> mediump_mat2x4; - /// 2 columns of 4 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 4 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier @@ -129,22 +129,22 @@ namespace detail /// @addtogroup core_precision /// @{ - /// 3 columns of 2 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 2 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 2, float, lowp> lowp_mat3x2; - /// 3 columns of 2 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 2 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 2, float, mediump> mediump_mat3x2; - /// 3 columns of 2 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 2 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier @@ -155,43 +155,43 @@ namespace detail /// @addtogroup core_precision /// @{ - /// 3 columns of 3 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 3 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, lowp> lowp_mat3; - /// 3 columns of 3 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 3 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, mediump> mediump_mat3; - /// 3 columns of 3 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 3 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, highp> highp_mat3; - /// 3 columns of 3 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 3 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, lowp> lowp_mat3x3; - /// 3 columns of 3 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 3 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, mediump> mediump_mat3x3; - /// 3 columns of 3 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 3 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier @@ -202,22 +202,22 @@ namespace detail /// @addtogroup core_precision /// @{ - /// 3 columns of 4 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 4 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 4, float, lowp> lowp_mat3x4; - /// 3 columns of 4 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 4 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 4, float, mediump> mediump_mat3x4; - /// 3 columns of 4 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 4 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier @@ -228,22 +228,22 @@ namespace detail /// @addtogroup core_precision /// @{ - /// 4 columns of 2 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 2 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 2, float, lowp> lowp_mat4x2; - /// 4 columns of 2 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 2 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 2, float, mediump> mediump_mat4x2; - /// 4 columns of 2 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 2 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier @@ -254,22 +254,22 @@ namespace detail /// @addtogroup core_precision /// @{ - /// 4 columns of 3 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 3 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 3, float, lowp> lowp_mat4x3; - /// 4 columns of 3 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 3 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 3, float, mediump> mediump_mat4x3; - /// 4 columns of 3 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 3 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier @@ -281,43 +281,43 @@ namespace detail /// @addtogroup core_precision /// @{ - /// 4 columns of 4 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 4 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, lowp> lowp_mat4; - /// 4 columns of 4 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 4 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, mediump> mediump_mat4; - /// 4 columns of 4 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 4 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, highp> highp_mat4; - /// 4 columns of 4 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 4 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, lowp> lowp_mat4x4; - /// 4 columns of 4 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 4 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, mediump> mediump_mat4x4; - /// 4 columns of 4 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 4 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier @@ -420,37 +420,37 @@ namespace detail /// @addtogroup core_precision /// @{ - /// 2 columns of 2 components matrix of low precision floating-point numbers. + /// 2 columns of 2 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, double, lowp> lowp_dmat2; - /// 2 columns of 2 components matrix of medium precision floating-point numbers. + /// 2 columns of 2 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, double, mediump> mediump_dmat2; - /// 2 columns of 2 components matrix of high precision floating-point numbers. + /// 2 columns of 2 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, double, highp> highp_dmat2; - /// 2 columns of 2 components matrix of low precision floating-point numbers. + /// 2 columns of 2 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, double, lowp> lowp_dmat2x2; - /// 2 columns of 2 components matrix of medium precision floating-point numbers. + /// 2 columns of 2 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, double, mediump> mediump_dmat2x2; - /// 2 columns of 2 components matrix of high precision floating-point numbers. + /// 2 columns of 2 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier @@ -461,19 +461,19 @@ namespace detail /// @addtogroup core_precision /// @{ - /// 2 columns of 3 components matrix of low precision floating-point numbers. + /// 2 columns of 3 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 3, double, lowp> lowp_dmat2x3; - /// 2 columns of 3 components matrix of medium precision floating-point numbers. + /// 2 columns of 3 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 3, double, mediump> mediump_dmat2x3; - /// 2 columns of 3 components matrix of high precision floating-point numbers. + /// 2 columns of 3 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier @@ -484,19 +484,19 @@ namespace detail /// @addtogroup core_precision /// @{ - /// 2 columns of 4 components matrix of low precision floating-point numbers. + /// 2 columns of 4 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 4, double, lowp> lowp_dmat2x4; - /// 2 columns of 4 components matrix of medium precision floating-point numbers. + /// 2 columns of 4 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 4, double, mediump> mediump_dmat2x4; - /// 2 columns of 4 components matrix of high precision floating-point numbers. + /// 2 columns of 4 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier @@ -507,19 +507,19 @@ namespace detail /// @addtogroup core_precision /// @{ - /// 3 columns of 2 components matrix of low precision floating-point numbers. + /// 3 columns of 2 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 2, double, lowp> lowp_dmat3x2; - /// 3 columns of 2 components matrix of medium precision floating-point numbers. + /// 3 columns of 2 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 2, double, mediump> mediump_dmat3x2; - /// 3 columns of 2 components matrix of high precision floating-point numbers. + /// 3 columns of 2 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier @@ -530,37 +530,37 @@ namespace detail /// @addtogroup core_precision /// @{ - /// 3 columns of 3 components matrix of low precision floating-point numbers. + /// 3 columns of 3 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, lowp> lowp_dmat3; - /// 3 columns of 3 components matrix of medium precision floating-point numbers. + /// 3 columns of 3 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, double, mediump> mediump_dmat3; - /// 3 columns of 3 components matrix of high precision floating-point numbers. + /// 3 columns of 3 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, double, highp> highp_dmat3; - /// 3 columns of 3 components matrix of low precision floating-point numbers. + /// 3 columns of 3 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, double, lowp> lowp_dmat3x3; - /// 3 columns of 3 components matrix of medium precision floating-point numbers. + /// 3 columns of 3 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, double, mediump> mediump_dmat3x3; - /// 3 columns of 3 components matrix of high precision floating-point numbers. + /// 3 columns of 3 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier @@ -571,19 +571,19 @@ namespace detail /// @addtogroup core_precision /// @{ - /// 3 columns of 4 components matrix of low precision floating-point numbers. + /// 3 columns of 4 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 4, double, lowp> lowp_dmat3x4; - /// 3 columns of 4 components matrix of medium precision floating-point numbers. + /// 3 columns of 4 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 4, double, mediump> mediump_dmat3x4; - /// 3 columns of 4 components matrix of high precision floating-point numbers. + /// 3 columns of 4 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier @@ -594,19 +594,19 @@ namespace detail /// @addtogroup core_precision /// @{ - /// 4 columns of 2 components matrix of low precision floating-point numbers. + /// 4 columns of 2 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 2, double, lowp> lowp_dmat4x2; - /// 4 columns of 2 components matrix of medium precision floating-point numbers. + /// 4 columns of 2 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 2, double, mediump> mediump_dmat4x2; - /// 4 columns of 2 components matrix of high precision floating-point numbers. + /// 4 columns of 2 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier @@ -617,19 +617,19 @@ namespace detail /// @addtogroup core_precision /// @{ - /// 4 columns of 3 components matrix of low precision floating-point numbers. + /// 4 columns of 3 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 3, double, lowp> lowp_dmat4x3; - /// 4 columns of 3 components matrix of medium precision floating-point numbers. + /// 4 columns of 3 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 3, double, mediump> mediump_dmat4x3; - /// 4 columns of 3 components matrix of high precision floating-point numbers. + /// 4 columns of 3 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier @@ -640,37 +640,37 @@ namespace detail /// @addtogroup core_precision /// @{ - /// 4 columns of 4 components matrix of low precision floating-point numbers. + /// 4 columns of 4 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, double, lowp> lowp_dmat4; - /// 4 columns of 4 components matrix of medium precision floating-point numbers. + /// 4 columns of 4 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, double, mediump> mediump_dmat4; - /// 4 columns of 4 components matrix of high precision floating-point numbers. + /// 4 columns of 4 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, double, highp> highp_dmat4; - /// 4 columns of 4 components matrix of low precision floating-point numbers. + /// 4 columns of 4 components matrix of low qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, double, lowp> lowp_dmat4x4; - /// 4 columns of 4 components matrix of medium precision floating-point numbers. + /// 4 columns of 4 components matrix of medium qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, double, mediump> mediump_dmat4x4; - /// 4 columns of 4 components matrix of high precision floating-point numbers. + /// 4 columns of 4 components matrix of high qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier @@ -700,62 +700,62 @@ namespace detail typedef mediump_dmat4x4 dmat4x4; #else //defined(GLM_PRECISION_HIGHP_DOUBLE) - //! 2 * 2 matrix of double-precision floating-point numbers. + //! 2 * 2 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat2x2 dmat2; - //! 3 * 3 matrix of double-precision floating-point numbers. + //! 3 * 3 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat3x3 dmat3; - //! 4 * 4 matrix of double-precision floating-point numbers. + //! 4 * 4 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat4x4 dmat4; - //! 2 * 2 matrix of double-precision floating-point numbers. + //! 2 * 2 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat2x2 dmat2x2; - //! 2 * 3 matrix of double-precision floating-point numbers. + //! 2 * 3 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat2x3 dmat2x3; - //! 2 * 4 matrix of double-precision floating-point numbers. + //! 2 * 4 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat2x4 dmat2x4; - //! 3 * 2 matrix of double-precision floating-point numbers. + //! 3 * 2 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat3x2 dmat3x2; - /// 3 * 3 matrix of double-precision floating-point numbers. + /// 3 * 3 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat3x3 dmat3x3; - /// 3 * 4 matrix of double-precision floating-point numbers. + /// 3 * 4 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat3x4 dmat3x4; - /// 4 * 2 matrix of double-precision floating-point numbers. + /// 4 * 2 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat4x2 dmat4x2; - /// 4 * 3 matrix of double-precision floating-point numbers. + /// 4 * 3 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat4x3 dmat4x3; - /// 4 * 4 matrix of double-precision floating-point numbers. + /// 4 * 4 matrix of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices typedef highp_dmat4x4 dmat4x4; diff --git a/glm/detail/type_mat2x2.hpp b/glm/detail/type_mat2x2.hpp index 16d28314..f366ddcd 100644 --- a/glm/detail/type_mat2x2.hpp +++ b/glm/detail/type_mat2x2.hpp @@ -11,7 +11,7 @@ namespace glm { - template + template struct mat<2, 2, T, P> { typedef vec<2, T, P> col_type; @@ -36,7 +36,7 @@ namespace glm GLM_FUNC_DECL mat() GLM_DEFAULT; GLM_FUNC_DECL mat(mat<2, 2, T, P> const & m) GLM_DEFAULT; - template + template GLM_FUNC_DECL mat(mat<2, 2, T, Q> const & m); GLM_FUNC_DECL explicit mat(T scalar); @@ -61,7 +61,7 @@ namespace glm // -- Matrix conversions -- - template + template GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, U, Q> const & m); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 3, T, P> const & x); @@ -106,74 +106,74 @@ namespace glm // -- Unary operators -- - template + template GLM_FUNC_DECL mat<2, 2, T, P> operator+(mat<2, 2, T, P> const & m); - template + template GLM_FUNC_DECL mat<2, 2, T, P> operator-(mat<2, 2, T, P> const & m); // -- Binary operators -- - template + template GLM_FUNC_DECL mat<2, 2, T, P> operator+(mat<2, 2, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<2, 2, T, P> operator+(T scalar, mat<2, 2, T, P> const & m); - template + template GLM_FUNC_DECL mat<2, 2, T, P> operator+(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2); - template + template GLM_FUNC_DECL mat<2, 2, T, P> operator-(mat<2, 2, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<2, 2, T, P> operator-(T scalar, mat<2, 2, T, P> const & m); - template + template GLM_FUNC_DECL mat<2, 2, T, P> operator-(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2); - template + template GLM_FUNC_DECL mat<2, 2, T, P> operator*(mat<2, 2, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<2, 2, T, P> operator*(T scalar, mat<2, 2, T, P> const & m); - template + template GLM_FUNC_DECL typename mat<2, 2, T, P>::col_type operator*(mat<2, 2, T, P> const & m, typename mat<2, 2, T, P>::row_type const & v); - template + template GLM_FUNC_DECL typename mat<2, 2, T, P>::row_type operator*(typename mat<2, 2, T, P>::col_type const & v, mat<2, 2, T, P> const & m); - template + template GLM_FUNC_DECL mat<2, 2, T, P> operator*(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2); - template + template GLM_FUNC_DECL mat<3, 2, T, P> operator*(mat<2, 2, T, P> const & m1, mat<3, 2, T, P> const & m2); - template + template GLM_FUNC_DECL mat<4, 2, T, P> operator*(mat<2, 2, T, P> const & m1, mat<4, 2, T, P> const & m2); - template + template GLM_FUNC_DECL mat<2, 2, T, P> operator/(mat<2, 2, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<2, 2, T, P> operator/(T scalar, mat<2, 2, T, P> const & m); - template + template GLM_FUNC_DECL typename mat<2, 2, T, P>::col_type operator/(mat<2, 2, T, P> const & m, typename mat<2, 2, T, P>::row_type const & v); - template + template GLM_FUNC_DECL typename mat<2, 2, T, P>::row_type operator/(typename mat<2, 2, T, P>::col_type const & v, mat<2, 2, T, P> const & m); - template + template GLM_FUNC_DECL mat<2, 2, T, P> operator/(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2); // -- Boolean operators -- - template + template GLM_FUNC_DECL bool operator==(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2); - template + template GLM_FUNC_DECL bool operator!=(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2); } //namespace glm diff --git a/glm/detail/type_mat2x2.inl b/glm/detail/type_mat2x2.inl index 9cda74a2..5d119619 100644 --- a/glm/detail/type_mat2x2.inl +++ b/glm/detail/type_mat2x2.inl @@ -8,13 +8,13 @@ namespace glm // -- Constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat() {} # endif # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<2, 2, T, P> const& m) { this->value[0] = m.value[0]; @@ -22,22 +22,22 @@ namespace glm } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template - template + template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<2, 2, T, Q> const& m) { this->value[0] = m.value[0]; this->value[1] = m.value[1]; } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(T scalar) { this->value[0] = col_type(scalar, 0); this->value[1] = col_type(0, scalar); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat ( T const & x0, T const & y0, @@ -48,7 +48,7 @@ namespace glm this->value[1] = col_type(x1, y1); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(col_type const& v0, col_type const& v1) { this->value[0] = v0; @@ -57,7 +57,7 @@ namespace glm // -- Conversion constructors -- - template + template template GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat ( @@ -69,7 +69,7 @@ namespace glm this->value[1] = col_type(static_cast(x2), value_type(y2)); } - template + template template GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(vec<2, V1, P> const& v1, vec<2, V2, P> const& v2) { @@ -79,64 +79,64 @@ namespace glm // -- mat2x2 matrix conversions -- - template - template + template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<2, 2, U, Q> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<3, 3, T, P> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<4, 4, T, P> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<2, 3, T, P> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<3, 2, T, P> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<2, 4, T, P> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<4, 2, T, P> const& m) { this->value[0] = m[0]; this->value[1] = m[1]; } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<3, 4, T, P> const& m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<4, 3, T, P> const& m) { this->value[0] = col_type(m[0]); @@ -145,14 +145,14 @@ namespace glm // -- Accesses -- - template + template GLM_FUNC_QUALIFIER typename mat<2, 2, T, P>::col_type& mat<2, 2, T, P>::operator[](typename mat<2, 2, T, P>::length_type i) { assert(i < this->length()); return this->value[i]; } - template + template GLM_FUNC_QUALIFIER typename mat<2, 2, T, P>::col_type const& mat<2, 2, T, P>::operator[](typename mat<2, 2, T, P>::length_type i) const { assert(i < this->length()); @@ -162,7 +162,7 @@ namespace glm // -- Unary updatable operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator=(mat<2, 2, T, P> const & m) { this->value[0] = m[0]; @@ -171,7 +171,7 @@ namespace glm } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template + template template GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator=(mat<2, 2, U, P> const & m) { @@ -180,7 +180,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator+=(U scalar) { @@ -189,7 +189,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator+=(mat<2, 2, U, P> const & m) { @@ -198,7 +198,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator-=(U scalar) { @@ -207,7 +207,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator-=(mat<2, 2, U, P> const & m) { @@ -216,7 +216,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator*=(U scalar) { @@ -225,14 +225,14 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator*=(mat<2, 2, U, P> const & m) { return (*this = *this * m); } - template + template template GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator/=(U scalar) { @@ -241,7 +241,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator/=(mat<2, 2, U, P> const & m) { @@ -250,7 +250,7 @@ namespace glm // -- Increment and decrement operators -- - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator++() { ++this->value[0]; @@ -258,7 +258,7 @@ namespace glm return *this; } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator--() { --this->value[0]; @@ -266,7 +266,7 @@ namespace glm return *this; } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> mat<2, 2, T, P>::operator++(int) { mat<2, 2, T, P> Result(*this); @@ -274,7 +274,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> mat<2, 2, T, P>::operator--(int) { mat<2, 2, T, P> Result(*this); @@ -284,13 +284,13 @@ namespace glm // -- Unary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator+(mat<2, 2, T, P> const & m) { return m; } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator-(mat<2, 2, T, P> const & m) { return mat<2, 2, T, P>( @@ -300,7 +300,7 @@ namespace glm // -- Binary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator+(mat<2, 2, T, P> const & m, T scalar) { return mat<2, 2, T, P>( @@ -308,7 +308,7 @@ namespace glm m[1] + scalar); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator+(T scalar, mat<2, 2, T, P> const & m) { return mat<2, 2, T, P>( @@ -316,7 +316,7 @@ namespace glm m[1] + scalar); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator+(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2) { return mat<2, 2, T, P>( @@ -324,7 +324,7 @@ namespace glm m1[1] + m2[1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator-(mat<2, 2, T, P> const & m, T scalar) { return mat<2, 2, T, P>( @@ -332,7 +332,7 @@ namespace glm m[1] - scalar); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator-(T scalar, mat<2, 2, T, P> const & m) { return mat<2, 2, T, P>( @@ -340,7 +340,7 @@ namespace glm scalar - m[1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator-(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2) { return mat<2, 2, T, P>( @@ -348,7 +348,7 @@ namespace glm m1[1] - m2[1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator*(mat<2, 2, T, P> const & m, T scalar) { return mat<2, 2, T, P>( @@ -356,7 +356,7 @@ namespace glm m[1] * scalar); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator*(T scalar, mat<2, 2, T, P> const & m) { return mat<2, 2, T, P>( @@ -364,7 +364,7 @@ namespace glm m[1] * scalar); } - template + template GLM_FUNC_QUALIFIER typename mat<2, 2, T, P>::col_type operator* ( mat<2, 2, T, P> const& m, @@ -376,7 +376,7 @@ namespace glm m[0][1] * v.x + m[1][1] * v.y); } - template + template GLM_FUNC_QUALIFIER typename mat<2, 2, T, P>::row_type operator* ( typename mat<2, 2, T, P>::col_type const & v, @@ -388,7 +388,7 @@ namespace glm v.x * m[1][0] + v.y * m[1][1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator*(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2) { return mat<2, 2, T, P>( @@ -398,7 +398,7 @@ namespace glm m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1]); } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator*(mat<2, 2, T, P> const & m1, mat<3, 2, T, P> const & m2) { return mat<3, 2, T, P>( @@ -410,7 +410,7 @@ namespace glm m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1]); } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator*(mat<2, 2, T, P> const & m1, mat<4, 2, T, P> const & m2) { return mat<4, 2, T, P>( @@ -424,7 +424,7 @@ namespace glm m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator/(mat<2, 2, T, P> const & m, T scalar) { return mat<2, 2, T, P>( @@ -432,7 +432,7 @@ namespace glm m[1] / scalar); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator/(T scalar, mat<2, 2, T, P> const & m) { return mat<2, 2, T, P>( @@ -440,19 +440,19 @@ namespace glm scalar / m[1]); } - template + template GLM_FUNC_QUALIFIER typename mat<2, 2, T, P>::col_type operator/(mat<2, 2, T, P> const & m, typename mat<2, 2, T, P>::row_type const & v) { return inverse(m) * v; } - template + template GLM_FUNC_QUALIFIER typename mat<2, 2, T, P>::row_type operator/(typename mat<2, 2, T, P>::col_type const & v, mat<2, 2, T, P> const & m) { return v * inverse(m); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator/(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2) { mat<2, 2, T, P> m1_copy(m1); @@ -461,13 +461,13 @@ namespace glm // -- Boolean operators -- - template + template GLM_FUNC_QUALIFIER bool operator==(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]); } - template + template GLM_FUNC_QUALIFIER bool operator!=(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]); diff --git a/glm/detail/type_mat2x3.hpp b/glm/detail/type_mat2x3.hpp index c4847b25..5d8240c3 100644 --- a/glm/detail/type_mat2x3.hpp +++ b/glm/detail/type_mat2x3.hpp @@ -12,7 +12,7 @@ namespace glm { - template + template struct mat<2, 3, T, P> { typedef vec<3, T, P> col_type; @@ -37,7 +37,7 @@ namespace glm GLM_FUNC_DECL mat() GLM_DEFAULT; GLM_FUNC_DECL mat(mat<2, 3, T, P> const & m) GLM_DEFAULT; - template + template GLM_FUNC_DECL mat(mat<2, 3, T, Q> const & m); GLM_FUNC_DECL explicit mat(T scalar); @@ -62,7 +62,7 @@ namespace glm // -- Matrix conversions -- - template + template GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 3, U, Q> const & m); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x); @@ -103,59 +103,59 @@ namespace glm // -- Unary operators -- - template + template GLM_FUNC_DECL mat<2, 3, T, P> operator+(mat<2, 3, T, P> const & m); - template + template GLM_FUNC_DECL mat<2, 3, T, P> operator-(mat<2, 3, T, P> const & m); // -- Binary operators -- - template + template GLM_FUNC_DECL mat<2, 3, T, P> operator+(mat<2, 3, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<2, 3, T, P> operator+(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2); - template + template GLM_FUNC_DECL mat<2, 3, T, P> operator-(mat<2, 3, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<2, 3, T, P> operator-(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2); - template + template GLM_FUNC_DECL mat<2, 3, T, P> operator*(mat<2, 3, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<2, 3, T, P> operator*(T scalar, mat<2, 3, T, P> const & m); - template + template GLM_FUNC_DECL typename mat<2, 3, T, P>::col_type operator*(mat<2, 3, T, P> const & m, typename mat<2, 3, T, P>::row_type const & v); - template + template GLM_FUNC_DECL typename mat<2, 3, T, P>::row_type operator*(typename mat<2, 3, T, P>::col_type const & v, mat<2, 3, T, P> const & m); - template + template GLM_FUNC_DECL mat<2, 3, T, P> operator*(mat<2, 3, T, P> const & m1, mat<2, 2, T, P> const & m2); - template + template GLM_FUNC_DECL mat<3, 3, T, P> operator*(mat<2, 3, T, P> const & m1, mat<3, 2, T, P> const & m2); - template + template GLM_FUNC_DECL mat<4, 3, T, P> operator*(mat<2, 3, T, P> const & m1, mat<4, 2, T, P> const & m2); - template + template GLM_FUNC_DECL mat<2, 3, T, P> operator/(mat<2, 3, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<2, 3, T, P> operator/(T scalar, mat<2, 3, T, P> const & m); // -- Boolean operators -- - template + template GLM_FUNC_DECL bool operator==(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2); - template + template GLM_FUNC_DECL bool operator!=(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2); }//namespace glm diff --git a/glm/detail/type_mat2x3.inl b/glm/detail/type_mat2x3.inl index c69fc78f..e554e04e 100644 --- a/glm/detail/type_mat2x3.inl +++ b/glm/detail/type_mat2x3.inl @@ -6,13 +6,13 @@ namespace glm // -- Constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat() {} # endif # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<2, 3, T, P> const & m) { this->value[0] = m.value[0]; @@ -20,22 +20,22 @@ namespace glm } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template - template + template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<2, 3, T, Q> const & m) { this->value[0] = m.value[0]; this->value[1] = m.value[1]; } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(T scalar) { this->value[0] = col_type(scalar, 0, 0); this->value[1] = col_type(0, scalar, 0); } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat ( T x0, T y0, T z0, @@ -46,7 +46,7 @@ namespace glm this->value[1] = col_type(x1, y1, z1); } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(col_type const & v0, col_type const & v1) { this->value[0] = v0; @@ -55,7 +55,7 @@ namespace glm // -- Conversion constructors -- - template + template template< typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2> @@ -69,7 +69,7 @@ namespace glm this->value[1] = col_type(static_cast(x2), value_type(y2), value_type(z2)); } - template + template template GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(vec<3, V1, P> const & v1, vec<3, V2, P> const & v2) { @@ -79,64 +79,64 @@ namespace glm // -- Matrix conversions -- - template - template + template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<2, 3, U, Q> const & m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<2, 2, T, P> const & m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<3, 3, T, P> const & m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<4, 4, T, P> const & m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<2, 4, T, P> const & m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<3, 2, T, P> const & m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<3, 4, T, P> const & m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<4, 2, T, P> const & m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<4, 3, T, P> const & m) { this->value[0] = m[0]; @@ -145,14 +145,14 @@ namespace glm // -- Accesses -- - template + template GLM_FUNC_QUALIFIER typename mat<2, 3, T, P>::col_type & mat<2, 3, T, P>::operator[](typename mat<2, 3, T, P>::length_type i) { assert(i < this->length()); return this->value[i]; } - template + template GLM_FUNC_QUALIFIER typename mat<2, 3, T, P>::col_type const & mat<2, 3, T, P>::operator[](typename mat<2, 3, T, P>::length_type i) const { assert(i < this->length()); @@ -162,7 +162,7 @@ namespace glm // -- Unary updatable operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P>& mat<2, 3, T, P>::operator=(mat<2, 3, T, P> const & m) { this->value[0] = m[0]; @@ -171,7 +171,7 @@ namespace glm } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template + template template GLM_FUNC_QUALIFIER mat<2, 3, T, P>& mat<2, 3, T, P>::operator=(mat<2, 3, U, P> const & m) { @@ -180,7 +180,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<2, 3, T, P> & mat<2, 3, T, P>::operator+=(U s) { @@ -189,7 +189,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<2, 3, T, P>& mat<2, 3, T, P>::operator+=(mat<2, 3, U, P> const & m) { @@ -198,7 +198,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<2, 3, T, P>& mat<2, 3, T, P>::operator-=(U s) { @@ -207,7 +207,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<2, 3, T, P>& mat<2, 3, T, P>::operator-=(mat<2, 3, U, P> const & m) { @@ -216,7 +216,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<2, 3, T, P>& mat<2, 3, T, P>::operator*=(U s) { @@ -225,7 +225,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<2, 3, T, P> & mat<2, 3, T, P>::operator/=(U s) { @@ -236,7 +236,7 @@ namespace glm // -- Increment and decrement operators -- - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P> & mat<2, 3, T, P>::operator++() { ++this->value[0]; @@ -244,7 +244,7 @@ namespace glm return *this; } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P> & mat<2, 3, T, P>::operator--() { --this->value[0]; @@ -252,7 +252,7 @@ namespace glm return *this; } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P> mat<2, 3, T, P>::operator++(int) { mat<2, 3, T, P> Result(*this); @@ -260,7 +260,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P> mat<2, 3, T, P>::operator--(int) { mat<2, 3, T, P> Result(*this); @@ -270,13 +270,13 @@ namespace glm // -- Unary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator+(mat<2, 3, T, P> const & m) { return m; } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator-(mat<2, 3, T, P> const & m) { return mat<2, 3, T, P>( @@ -286,7 +286,7 @@ namespace glm // -- Binary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator+(mat<2, 3, T, P> const & m, T scalar) { return mat<2, 3, T, P>( @@ -294,7 +294,7 @@ namespace glm m[1] + scalar); } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator+(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2) { return mat<2, 3, T, P>( @@ -302,7 +302,7 @@ namespace glm m1[1] + m2[1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator-(mat<2, 3, T, P> const & m, T scalar) { return mat<2, 3, T, P>( @@ -310,7 +310,7 @@ namespace glm m[1] - scalar); } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator-(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2) { return mat<2, 3, T, P>( @@ -318,7 +318,7 @@ namespace glm m1[1] - m2[1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator*(mat<2, 3, T, P> const & m, T scalar) { return mat<2, 3, T, P>( @@ -326,7 +326,7 @@ namespace glm m[1] * scalar); } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator*(T scalar, mat<2, 3, T, P> const & m) { return mat<2, 3, T, P>( @@ -334,7 +334,7 @@ namespace glm m[1] * scalar); } - template + template GLM_FUNC_QUALIFIER typename mat<2, 3, T, P>::col_type operator* ( mat<2, 3, T, P> const& m, @@ -346,7 +346,7 @@ namespace glm m[0][2] * v.x + m[1][2] * v.y); } - template + template GLM_FUNC_QUALIFIER typename mat<2, 3, T, P>::row_type operator* ( typename mat<2, 3, T, P>::col_type const & v, @@ -357,7 +357,7 @@ namespace glm v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2]); } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator*(mat<2, 3, T, P> const & m1, mat<2, 2, T, P> const & m2) { return mat<2, 3, T, P>( @@ -369,7 +369,7 @@ namespace glm m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1]); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator*(mat<2, 3, T, P> const & m1, mat<3, 2, T, P> const & m2) { T SrcA00 = m1[0][0]; @@ -399,7 +399,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator*(mat<2, 3, T, P> const & m1, mat<4, 2, T, P> const & m2) { return mat<4, 3, T, P>( @@ -417,7 +417,7 @@ namespace glm m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator/(mat<2, 3, T, P> const & m, T scalar) { return mat<2, 3, T, P>( @@ -425,7 +425,7 @@ namespace glm m[1] / scalar); } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator/(T scalar, mat<2, 3, T, P> const & m) { return mat<2, 3, T, P>( @@ -435,13 +435,13 @@ namespace glm // -- Boolean operators -- - template + template GLM_FUNC_QUALIFIER bool operator==(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]); } - template + template GLM_FUNC_QUALIFIER bool operator!=(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]); diff --git a/glm/detail/type_mat2x4.hpp b/glm/detail/type_mat2x4.hpp index bd4cf779..c149a447 100644 --- a/glm/detail/type_mat2x4.hpp +++ b/glm/detail/type_mat2x4.hpp @@ -12,7 +12,7 @@ namespace glm { - template + template struct mat<2, 4, T, P> { typedef vec<4, T, P> col_type; @@ -37,7 +37,7 @@ namespace glm GLM_FUNC_DECL mat() GLM_DEFAULT; GLM_FUNC_DECL mat(mat<2, 4, T, P> const & m) GLM_DEFAULT; - template + template GLM_FUNC_DECL mat(mat<2, 4, T, Q> const & m); GLM_FUNC_DECL explicit mat(T scalar); @@ -64,7 +64,7 @@ namespace glm // -- Matrix conversions -- - template + template GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 4, U, Q> const & m); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x); @@ -105,59 +105,59 @@ namespace glm // -- Unary operators -- - template + template GLM_FUNC_DECL mat<2, 4, T, P> operator+(mat<2, 4, T, P> const & m); - template + template GLM_FUNC_DECL mat<2, 4, T, P> operator-(mat<2, 4, T, P> const & m); // -- Binary operators -- - template + template GLM_FUNC_DECL mat<2, 4, T, P> operator+(mat<2, 4, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<2, 4, T, P> operator+(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2); - template + template GLM_FUNC_DECL mat<2, 4, T, P> operator-(mat<2, 4, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<2, 4, T, P> operator-(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2); - template + template GLM_FUNC_DECL mat<2, 4, T, P> operator*(mat<2, 4, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<2, 4, T, P> operator*(T scalar, mat<2, 4, T, P> const & m); - template + template GLM_FUNC_DECL typename mat<2, 4, T, P>::col_type operator*(mat<2, 4, T, P> const & m, typename mat<2, 4, T, P>::row_type const & v); - template + template GLM_FUNC_DECL typename mat<2, 4, T, P>::row_type operator*(typename mat<2, 4, T, P>::col_type const & v, mat<2, 4, T, P> const & m); - template + template GLM_FUNC_DECL mat<4, 4, T, P> operator*(mat<2, 4, T, P> const & m1, mat<4, 2, T, P> const & m2); - template + template GLM_FUNC_DECL mat<2, 4, T, P> operator*(mat<2, 4, T, P> const & m1, mat<2, 2, T, P> const & m2); - template + template GLM_FUNC_DECL mat<3, 4, T, P> operator*(mat<2, 4, T, P> const & m1, mat<3, 2, T, P> const & m2); - template + template GLM_FUNC_DECL mat<2, 4, T, P> operator/(mat<2, 4, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<2, 4, T, P> operator/(T scalar, mat<2, 4, T, P> const & m); // -- Boolean operators -- - template + template GLM_FUNC_DECL bool operator==(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2); - template + template GLM_FUNC_DECL bool operator!=(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2); }//namespace glm diff --git a/glm/detail/type_mat2x4.inl b/glm/detail/type_mat2x4.inl index 61c9fb28..9c9a4e41 100644 --- a/glm/detail/type_mat2x4.inl +++ b/glm/detail/type_mat2x4.inl @@ -6,13 +6,13 @@ namespace glm // -- Constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat() {} # endif # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<2, 4, T, P> const & m) { this->value[0] = m.value[0]; @@ -20,15 +20,15 @@ namespace glm } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template - template + template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<2, 4, T, Q> const & m) { this->value[0] = m.value[0]; this->value[1] = m.value[1]; } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(T scalar) { value_type const Zero(0); @@ -36,7 +36,7 @@ namespace glm this->value[1] = col_type(Zero, scalar, Zero, Zero); } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat ( T x0, T y0, T z0, T w0, @@ -47,7 +47,7 @@ namespace glm this->value[1] = col_type(x1, y1, z1, w1); } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(col_type const & v0, col_type const & v1) { this->value[0] = v0; @@ -56,7 +56,7 @@ namespace glm // -- Conversion constructors -- - template + template template< typename X1, typename Y1, typename Z1, typename W1, typename X2, typename Y2, typename Z2, typename W2> @@ -70,7 +70,7 @@ namespace glm this->value[1] = col_type(static_cast(x2), value_type(y2), value_type(z2), value_type(w2)); } - template + template template GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(vec<4, V1, P> const & v1, vec<4, V2, P> const & v2) { @@ -80,64 +80,64 @@ namespace glm // -- Matrix conversions -- - template - template + template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<2, 4, U, Q> const & m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<2, 2, T, P> const & m) { this->value[0] = col_type(m[0], 0, 0); this->value[1] = col_type(m[1], 0, 0); } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<3, 3, T, P> const & m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<4, 4, T, P> const & m) { this->value[0] = col_type(m[0]); this->value[1] = col_type(m[1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<2, 3, T, P> const & m) { this->value[0] = col_type(m[0], 0); this->value[1] = col_type(m[1], 0); } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<3, 2, T, P> const & m) { this->value[0] = col_type(m[0], 0, 0); this->value[1] = col_type(m[1], 0, 0); } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<3, 4, T, P> const & m) { this->value[0] = m[0]; this->value[1] = m[1]; } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<4, 2, T, P> const & m) { this->value[0] = col_type(m[0], 0, 0); this->value[1] = col_type(m[1], 0, 0); } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<4, 3, T, P> const & m) { this->value[0] = col_type(m[0], 0); @@ -146,14 +146,14 @@ namespace glm // -- Accesses -- - template + template GLM_FUNC_QUALIFIER typename mat<2, 4, T, P>::col_type & mat<2, 4, T, P>::operator[](typename mat<2, 4, T, P>::length_type i) { assert(i < this->length()); return this->value[i]; } - template + template GLM_FUNC_QUALIFIER typename mat<2, 4, T, P>::col_type const & mat<2, 4, T, P>::operator[](typename mat<2, 4, T, P>::length_type i) const { assert(i < this->length()); @@ -163,7 +163,7 @@ namespace glm // -- Unary updatable operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator=(mat<2, 4, T, P> const & m) { this->value[0] = m[0]; @@ -172,7 +172,7 @@ namespace glm } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template + template template GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator=(mat<2, 4, U, P> const & m) { @@ -181,7 +181,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator+=(U s) { @@ -190,7 +190,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator+=(mat<2, 4, U, P> const & m) { @@ -199,7 +199,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator-=(U s) { @@ -208,7 +208,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator-=(mat<2, 4, U, P> const & m) { @@ -217,7 +217,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator*=(U s) { @@ -226,7 +226,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<2, 4, T, P> & mat<2, 4, T, P>::operator/=(U s) { @@ -237,7 +237,7 @@ namespace glm // -- Increment and decrement operators -- - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator++() { ++this->value[0]; @@ -245,7 +245,7 @@ namespace glm return *this; } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator--() { --this->value[0]; @@ -253,7 +253,7 @@ namespace glm return *this; } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P> mat<2, 4, T, P>::operator++(int) { mat<2, 4, T, P> Result(*this); @@ -261,7 +261,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P> mat<2, 4, T, P>::operator--(int) { mat<2, 4, T, P> Result(*this); @@ -271,13 +271,13 @@ namespace glm // -- Unary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator+(mat<2, 4, T, P> const & m) { return m; } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator-(mat<2, 4, T, P> const & m) { return mat<2, 4, T, P>( @@ -287,7 +287,7 @@ namespace glm // -- Binary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator+(mat<2, 4, T, P> const & m, T scalar) { return mat<2, 4, T, P>( @@ -295,7 +295,7 @@ namespace glm m[1] + scalar); } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator+(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2) { return mat<2, 4, T, P>( @@ -303,7 +303,7 @@ namespace glm m1[1] + m2[1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator-(mat<2, 4, T, P> const & m, T scalar) { return mat<2, 4, T, P>( @@ -311,7 +311,7 @@ namespace glm m[1] - scalar); } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator-(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2) { return mat<2, 4, T, P>( @@ -319,7 +319,7 @@ namespace glm m1[1] - m2[1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator*(mat<2, 4, T, P> const & m, T scalar) { return mat<2, 4, T, P>( @@ -327,7 +327,7 @@ namespace glm m[1] * scalar); } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator*(T scalar, mat<2, 4, T, P> const & m) { return mat<2, 4, T, P>( @@ -335,7 +335,7 @@ namespace glm m[1] * scalar); } - template + template GLM_FUNC_QUALIFIER typename mat<2, 4, T, P>::col_type operator*(mat<2, 4, T, P> const & m, typename mat<2, 4, T, P>::row_type const & v) { return typename mat<2, 4, T, P>::col_type( @@ -345,7 +345,7 @@ namespace glm m[0][3] * v.x + m[1][3] * v.y); } - template + template GLM_FUNC_QUALIFIER typename mat<2, 4, T, P>::row_type operator*(typename mat<2, 4, T, P>::col_type const & v, mat<2, 4, T, P> const & m) { return typename mat<2, 4, T, P>::row_type( @@ -353,7 +353,7 @@ namespace glm v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3]); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator*(mat<2, 4, T, P> const & m1, mat<4, 2, T, P> const & m2) { T SrcA00 = m1[0][0]; @@ -394,7 +394,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator*(mat<2, 4, T, P> const & m1, mat<2, 2, T, P> const & m2) { return mat<2, 4, T, P>( @@ -408,7 +408,7 @@ namespace glm m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1]); } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator*(mat<2, 4, T, P> const & m1, mat<3, 2, T, P> const & m2) { return mat<3, 4, T, P>( @@ -426,7 +426,7 @@ namespace glm m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator/(mat<2, 4, T, P> const & m, T scalar) { return mat<2, 4, T, P>( @@ -434,7 +434,7 @@ namespace glm m[1] / scalar); } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator/(T scalar, mat<2, 4, T, P> const & m) { return mat<2, 4, T, P>( @@ -444,13 +444,13 @@ namespace glm // -- Boolean operators -- - template + template GLM_FUNC_QUALIFIER bool operator==(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]); } - template + template GLM_FUNC_QUALIFIER bool operator!=(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]); diff --git a/glm/detail/type_mat3x2.hpp b/glm/detail/type_mat3x2.hpp index 8331003b..b1b91bab 100644 --- a/glm/detail/type_mat3x2.hpp +++ b/glm/detail/type_mat3x2.hpp @@ -12,7 +12,7 @@ namespace glm { - template + template struct mat<3, 2, T, P> { typedef vec<2, T, P> col_type; @@ -37,7 +37,7 @@ namespace glm GLM_FUNC_DECL mat() GLM_DEFAULT; GLM_FUNC_DECL mat(mat<3, 2, T, P> const & m) GLM_DEFAULT; - template + template GLM_FUNC_DECL mat(mat<3, 2, T, Q> const & m); GLM_FUNC_DECL explicit mat(T scalar); @@ -69,7 +69,7 @@ namespace glm // -- Matrix conversions -- - template + template GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 2, U, Q> const & m); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x); @@ -110,59 +110,59 @@ namespace glm // -- Unary operators -- - template + template GLM_FUNC_DECL mat<3, 2, T, P> operator+(mat<3, 2, T, P> const & m); - template + template GLM_FUNC_DECL mat<3, 2, T, P> operator-(mat<3, 2, T, P> const & m); // -- Binary operators -- - template + template GLM_FUNC_DECL mat<3, 2, T, P> operator+(mat<3, 2, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<3, 2, T, P> operator+(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2); - template + template GLM_FUNC_DECL mat<3, 2, T, P> operator-(mat<3, 2, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<3, 2, T, P> operator-(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2); - template + template GLM_FUNC_DECL mat<3, 2, T, P> operator*(mat<3, 2, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<3, 2, T, P> operator*(T scalar, mat<3, 2, T, P> const & m); - template + template GLM_FUNC_DECL typename mat<3, 2, T, P>::col_type operator*(mat<3, 2, T, P> const & m, typename mat<3, 2, T, P>::row_type const & v); - template + template GLM_FUNC_DECL typename mat<3, 2, T, P>::row_type operator*(typename mat<3, 2, T, P>::col_type const & v, mat<3, 2, T, P> const & m); - template + template GLM_FUNC_DECL mat<2, 2, T, P> operator*(mat<3, 2, T, P> const & m1, mat<2, 3, T, P> const & m2); - template + template GLM_FUNC_DECL mat<3, 2, T, P> operator*(mat<3, 2, T, P> const & m1, mat<3, 3, T, P> const & m2); - template + template GLM_FUNC_DECL mat<4, 2, T, P> operator*(mat<3, 2, T, P> const & m1, mat<4, 3, T, P> const & m2); - template + template GLM_FUNC_DECL mat<3, 2, T, P> operator/(mat<3, 2, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<3, 2, T, P> operator/(T scalar, mat<3, 2, T, P> const & m); // -- Boolean operators -- - template + template GLM_FUNC_DECL bool operator==(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2); - template + template GLM_FUNC_DECL bool operator!=(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2); }//namespace glm diff --git a/glm/detail/type_mat3x2.inl b/glm/detail/type_mat3x2.inl index 95a733fa..015359bd 100644 --- a/glm/detail/type_mat3x2.inl +++ b/glm/detail/type_mat3x2.inl @@ -6,13 +6,13 @@ namespace glm // -- Constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat() {} # endif # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<3, 2, T, P> const & m) { this->value[0] = m.value[0]; @@ -21,8 +21,8 @@ namespace glm } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template - template + template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<3, 2, T, Q> const & m) { this->value[0] = m.value[0]; @@ -30,7 +30,7 @@ namespace glm this->value[2] = m.value[2]; } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(T scalar) { this->value[0] = col_type(scalar, 0); @@ -38,7 +38,7 @@ namespace glm this->value[2] = col_type(0, 0); } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat ( T x0, T y0, @@ -51,7 +51,7 @@ namespace glm this->value[2] = col_type(x2, y2); } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat ( col_type const & v0, @@ -66,7 +66,7 @@ namespace glm // -- Conversion constructors -- - template + template template< typename X1, typename Y1, typename X2, typename Y2, @@ -83,7 +83,7 @@ namespace glm this->value[2] = col_type(static_cast(x3), value_type(y3)); } - template + template template GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat ( @@ -99,8 +99,8 @@ namespace glm // -- Matrix conversions -- - template - template + template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<3, 2, U, Q> const & m) { this->value[0] = col_type(m[0]); @@ -108,7 +108,7 @@ namespace glm this->value[2] = col_type(m[2]); } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<2, 2, T, P> const & m) { this->value[0] = m[0]; @@ -116,7 +116,7 @@ namespace glm this->value[2] = col_type(0); } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<3, 3, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -124,7 +124,7 @@ namespace glm this->value[2] = col_type(m[2]); } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<4, 4, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -132,7 +132,7 @@ namespace glm this->value[2] = col_type(m[2]); } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<2, 3, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -140,7 +140,7 @@ namespace glm this->value[2] = col_type(T(0)); } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<2, 4, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -148,7 +148,7 @@ namespace glm this->value[2] = col_type(T(0)); } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<3, 4, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -156,7 +156,7 @@ namespace glm this->value[2] = col_type(m[2]); } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<4, 2, T, P> const & m) { this->value[0] = m[0]; @@ -164,7 +164,7 @@ namespace glm this->value[2] = m[2]; } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<4, 3, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -174,14 +174,14 @@ namespace glm // -- Accesses -- - template + template GLM_FUNC_QUALIFIER typename mat<3, 2, T, P>::col_type & mat<3, 2, T, P>::operator[](typename mat<3, 2, T, P>::length_type i) { assert(i < this->length()); return this->value[i]; } - template + template GLM_FUNC_QUALIFIER typename mat<3, 2, T, P>::col_type const & mat<3, 2, T, P>::operator[](typename mat<3, 2, T, P>::length_type i) const { assert(i < this->length()); @@ -191,7 +191,7 @@ namespace glm // -- Unary updatable operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator=(mat<3, 2, T, P> const & m) { this->value[0] = m[0]; @@ -201,7 +201,7 @@ namespace glm } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template + template template GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator=(mat<3, 2, U, P> const & m) { @@ -211,7 +211,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator+=(U s) { @@ -221,7 +221,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator+=(mat<3, 2, U, P> const & m) { @@ -231,7 +231,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator-=(U s) { @@ -241,7 +241,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator-=(mat<3, 2, U, P> const & m) { @@ -251,7 +251,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator*=(U s) { @@ -261,7 +261,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<3, 2, T, P> & mat<3, 2, T, P>::operator/=(U s) { @@ -273,7 +273,7 @@ namespace glm // -- Increment and decrement operators -- - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator++() { ++this->value[0]; @@ -282,7 +282,7 @@ namespace glm return *this; } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator--() { --this->value[0]; @@ -291,7 +291,7 @@ namespace glm return *this; } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P> mat<3, 2, T, P>::operator++(int) { mat<3, 2, T, P> Result(*this); @@ -299,7 +299,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P> mat<3, 2, T, P>::operator--(int) { mat<3, 2, T, P> Result(*this); @@ -309,13 +309,13 @@ namespace glm // -- Unary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator+(mat<3, 2, T, P> const & m) { return m; } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator-(mat<3, 2, T, P> const & m) { return mat<3, 2, T, P>( @@ -326,7 +326,7 @@ namespace glm // -- Binary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator+(mat<3, 2, T, P> const & m, T scalar) { return mat<3, 2, T, P>( @@ -335,7 +335,7 @@ namespace glm m[2] + scalar); } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator+(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2) { return mat<3, 2, T, P>( @@ -344,7 +344,7 @@ namespace glm m1[2] + m2[2]); } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator-(mat<3, 2, T, P> const & m, T scalar) { return mat<3, 2, T, P>( @@ -353,7 +353,7 @@ namespace glm m[2] - scalar); } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator-(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2) { return mat<3, 2, T, P>( @@ -362,7 +362,7 @@ namespace glm m1[2] - m2[2]); } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator*(mat<3, 2, T, P> const & m, T scalar) { return mat<3, 2, T, P>( @@ -371,7 +371,7 @@ namespace glm m[2] * scalar); } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator*(T scalar, mat<3, 2, T, P> const & m) { return mat<3, 2, T, P>( @@ -380,7 +380,7 @@ namespace glm m[2] * scalar); } - template + template GLM_FUNC_QUALIFIER typename mat<3, 2, T, P>::col_type operator*(mat<3, 2, T, P> const & m, typename mat<3, 2, T, P>::row_type const & v) { return typename mat<3, 2, T, P>::col_type( @@ -388,7 +388,7 @@ namespace glm m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z); } - template + template GLM_FUNC_QUALIFIER typename mat<3, 2, T, P>::row_type operator*(typename mat<3, 2, T, P>::col_type const & v, mat<3, 2, T, P> const & m) { return typename mat<3, 2, T, P>::row_type( @@ -397,7 +397,7 @@ namespace glm v.x * m[2][0] + v.y * m[2][1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator*(mat<3, 2, T, P> const & m1, mat<2, 3, T, P> const & m2) { const T SrcA00 = m1[0][0]; @@ -422,7 +422,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator*(mat<3, 2, T, P> const & m1, mat<3, 3, T, P> const & m2) { return mat<3, 2, T, P>( @@ -434,7 +434,7 @@ namespace glm m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2]); } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator*(mat<3, 2, T, P> const & m1, mat<4, 3, T, P> const & m2) { return mat<4, 2, T, P>( @@ -448,7 +448,7 @@ namespace glm m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2]); } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator/(mat<3, 2, T, P> const & m, T scalar) { return mat<3, 2, T, P>( @@ -457,7 +457,7 @@ namespace glm m[2] / scalar); } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator/(T scalar, mat<3, 2, T, P> const & m) { return mat<3, 2, T, P>( @@ -468,13 +468,13 @@ namespace glm // -- Boolean operators -- - template + template GLM_FUNC_QUALIFIER bool operator==(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]); } - template + template GLM_FUNC_QUALIFIER bool operator!=(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]); diff --git a/glm/detail/type_mat3x3.hpp b/glm/detail/type_mat3x3.hpp index fd1e3afb..e5cac05b 100644 --- a/glm/detail/type_mat3x3.hpp +++ b/glm/detail/type_mat3x3.hpp @@ -11,7 +11,7 @@ namespace glm { - template + template struct mat<3, 3, T, P> { typedef vec<3, T, P> col_type; @@ -36,7 +36,7 @@ namespace glm GLM_FUNC_DECL mat() GLM_DEFAULT; GLM_FUNC_DECL mat(mat<3, 3, T, P> const & m) GLM_DEFAULT; - template + template GLM_FUNC_DECL mat(mat<3, 3, T, Q> const & m); GLM_FUNC_DECL explicit mat(T scalar); @@ -68,7 +68,7 @@ namespace glm // -- Matrix conversions -- - template + template GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 3, U, Q> const & m); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x); @@ -113,74 +113,74 @@ namespace glm // -- Unary operators -- - template + template GLM_FUNC_DECL mat<3, 3, T, P> operator+(mat<3, 3, T, P> const & m); - template + template GLM_FUNC_DECL mat<3, 3, T, P> operator-(mat<3, 3, T, P> const & m); // -- Binary operators -- - template + template GLM_FUNC_DECL mat<3, 3, T, P> operator+(mat<3, 3, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<3, 3, T, P> operator+(T scalar, mat<3, 3, T, P> const & m); - template + template GLM_FUNC_DECL mat<3, 3, T, P> operator+(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2); - template + template GLM_FUNC_DECL mat<3, 3, T, P> operator-(mat<3, 3, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<3, 3, T, P> operator-(T scalar, mat<3, 3, T, P> const & m); - template + template GLM_FUNC_DECL mat<3, 3, T, P> operator-(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2); - template + template GLM_FUNC_DECL mat<3, 3, T, P> operator*(mat<3, 3, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<3, 3, T, P> operator*(T scalar, mat<3, 3, T, P> const & m); - template + template GLM_FUNC_DECL typename mat<3, 3, T, P>::col_type operator*(mat<3, 3, T, P> const & m, typename mat<3, 3, T, P>::row_type const & v); - template + template GLM_FUNC_DECL typename mat<3, 3, T, P>::row_type operator*(typename mat<3, 3, T, P>::col_type const & v, mat<3, 3, T, P> const & m); - template + template GLM_FUNC_DECL mat<3, 3, T, P> operator*(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2); - template + template GLM_FUNC_DECL mat<2, 3, T, P> operator*(mat<3, 3, T, P> const & m1, mat<2, 3, T, P> const & m2); - template + template GLM_FUNC_DECL mat<4, 3, T, P> operator*(mat<3, 3, T, P> const & m1, mat<4, 3, T, P> const & m2); - template + template GLM_FUNC_DECL mat<3, 3, T, P> operator/(mat<3, 3, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<3, 3, T, P> operator/(T scalar, mat<3, 3, T, P> const & m); - template + template GLM_FUNC_DECL typename mat<3, 3, T, P>::col_type operator/(mat<3, 3, T, P> const & m, typename mat<3, 3, T, P>::row_type const & v); - template + template GLM_FUNC_DECL typename mat<3, 3, T, P>::row_type operator/(typename mat<3, 3, T, P>::col_type const & v, mat<3, 3, T, P> const & m); - template + template GLM_FUNC_DECL mat<3, 3, T, P> operator/(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2); // -- Boolean operators -- - template + template GLM_FUNC_DECL bool operator==(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2); - template + template GLM_FUNC_DECL bool operator!=(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2); }//namespace glm diff --git a/glm/detail/type_mat3x3.inl b/glm/detail/type_mat3x3.inl index 2b5b5815..26737765 100644 --- a/glm/detail/type_mat3x3.inl +++ b/glm/detail/type_mat3x3.inl @@ -8,13 +8,13 @@ namespace glm // -- Constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat() {} # endif # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<3, 3, T, P> const & m) { this->value[0] = m.value[0]; @@ -23,8 +23,8 @@ namespace glm } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template - template + template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<3, 3, T, Q> const & m) { this->value[0] = m.value[0]; @@ -32,7 +32,7 @@ namespace glm this->value[2] = m.value[2]; } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(T scalar) { this->value[0] = col_type(scalar, 0, 0); @@ -40,7 +40,7 @@ namespace glm this->value[2] = col_type(0, 0, scalar); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat ( T x0, T y0, T z0, @@ -53,7 +53,7 @@ namespace glm this->value[2] = col_type(x2, y2, z2); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat ( col_type const & v0, @@ -68,7 +68,7 @@ namespace glm // -- Conversion constructors -- - template + template template< typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2, @@ -85,7 +85,7 @@ namespace glm this->value[2] = col_type(static_cast(x3), value_type(y3), value_type(z3)); } - template + template template GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat ( @@ -101,8 +101,8 @@ namespace glm // -- Matrix conversions -- - template - template + template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<3, 3, U, Q> const & m) { this->value[0] = col_type(m[0]); @@ -110,7 +110,7 @@ namespace glm this->value[2] = col_type(m[2]); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<2, 2, T, P> const & m) { this->value[0] = col_type(m[0], 0); @@ -118,7 +118,7 @@ namespace glm this->value[2] = col_type(0, 0, 1); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<4, 4, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -126,7 +126,7 @@ namespace glm this->value[2] = col_type(m[2]); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<2, 3, T, P> const & m) { this->value[0] = m[0]; @@ -134,7 +134,7 @@ namespace glm this->value[2] = col_type(0, 0, 1); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<3, 2, T, P> const & m) { this->value[0] = col_type(m[0], 0); @@ -142,7 +142,7 @@ namespace glm this->value[2] = col_type(m[2], 1); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<2, 4, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -150,7 +150,7 @@ namespace glm this->value[2] = col_type(0, 0, 1); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<4, 2, T, P> const & m) { this->value[0] = col_type(m[0], 0); @@ -158,7 +158,7 @@ namespace glm this->value[2] = col_type(m[2], 1); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<3, 4, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -166,7 +166,7 @@ namespace glm this->value[2] = col_type(m[2]); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<4, 3, T, P> const & m) { this->value[0] = m[0]; @@ -176,14 +176,14 @@ namespace glm // -- Accesses -- - template + template GLM_FUNC_QUALIFIER typename mat<3, 3, T, P>::col_type & mat<3, 3, T, P>::operator[](typename mat<3, 3, T, P>::length_type i) { assert(i < this->length()); return this->value[i]; } - template + template GLM_FUNC_QUALIFIER typename mat<3, 3, T, P>::col_type const & mat<3, 3, T, P>::operator[](typename mat<3, 3, T, P>::length_type i) const { assert(i < this->length()); @@ -193,7 +193,7 @@ namespace glm // -- Unary updatable operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator=(mat<3, 3, T, P> const & m) { this->value[0] = m[0]; @@ -203,7 +203,7 @@ namespace glm } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template + template template GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator=(mat<3, 3, U, P> const & m) { @@ -213,7 +213,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator+=(U s) { @@ -223,7 +223,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator+=(mat<3, 3, U, P> const & m) { @@ -233,7 +233,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator-=(U s) { @@ -243,7 +243,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator-=(mat<3, 3, U, P> const & m) { @@ -253,7 +253,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator*=(U s) { @@ -263,14 +263,14 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator*=(mat<3, 3, U, P> const & m) { return (*this = *this * m); } - template + template template GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator/=(U s) { @@ -280,7 +280,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator/=(mat<3, 3, U, P> const & m) { @@ -289,7 +289,7 @@ namespace glm // -- Increment and decrement operators -- - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator++() { ++this->value[0]; @@ -298,7 +298,7 @@ namespace glm return *this; } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator--() { --this->value[0]; @@ -307,7 +307,7 @@ namespace glm return *this; } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> mat<3, 3, T, P>::operator++(int) { mat<3, 3, T, P> Result(*this); @@ -315,7 +315,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> mat<3, 3, T, P>::operator--(int) { mat<3, 3, T, P> Result(*this); @@ -325,13 +325,13 @@ namespace glm // -- Unary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator+(mat<3, 3, T, P> const & m) { return m; } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator-(mat<3, 3, T, P> const & m) { return mat<3, 3, T, P>( @@ -342,7 +342,7 @@ namespace glm // -- Binary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator+(mat<3, 3, T, P> const & m, T scalar) { return mat<3, 3, T, P>( @@ -351,7 +351,7 @@ namespace glm m[2] + scalar); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator+(T scalar, mat<3, 3, T, P> const & m) { return mat<3, 3, T, P>( @@ -360,7 +360,7 @@ namespace glm m[2] + scalar); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator+(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2) { return mat<3, 3, T, P>( @@ -369,7 +369,7 @@ namespace glm m1[2] + m2[2]); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator-(mat<3, 3, T, P> const & m, T scalar) { return mat<3, 3, T, P>( @@ -378,7 +378,7 @@ namespace glm m[2] - scalar); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator-(T scalar, mat<3, 3, T, P> const & m) { return mat<3, 3, T, P>( @@ -387,7 +387,7 @@ namespace glm scalar - m[2]); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator-(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2) { return mat<3, 3, T, P>( @@ -396,7 +396,7 @@ namespace glm m1[2] - m2[2]); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator*(mat<3, 3, T, P> const & m, T scalar) { return mat<3, 3, T, P>( @@ -405,7 +405,7 @@ namespace glm m[2] * scalar); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator*(T scalar, mat<3, 3, T, P> const & m) { return mat<3, 3, T, P>( @@ -414,7 +414,7 @@ namespace glm m[2] * scalar); } - template + template GLM_FUNC_QUALIFIER typename mat<3, 3, T, P>::col_type operator*(mat<3, 3, T, P> const & m, typename mat<3, 3, T, P>::row_type const & v) { return typename mat<3, 3, T, P>::col_type( @@ -423,7 +423,7 @@ namespace glm m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z); } - template + template GLM_FUNC_QUALIFIER typename mat<3, 3, T, P>::row_type operator*(typename mat<3, 3, T, P>::col_type const & v, mat<3, 3, T, P> const & m) { return typename mat<3, 3, T, P>::row_type( @@ -432,7 +432,7 @@ namespace glm m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator*(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2) { T const SrcA00 = m1[0][0]; @@ -468,7 +468,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator*(mat<3, 3, T, P> const & m1, mat<2, 3, T, P> const & m2) { return mat<2, 3, T, P>( @@ -480,7 +480,7 @@ namespace glm m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2]); } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator*(mat<3, 3, T, P> const & m1, mat<4, 3, T, P> const & m2) { return mat<4, 3, T, P>( @@ -498,7 +498,7 @@ namespace glm m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2]); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator/(mat<3, 3, T, P> const & m, T scalar) { return mat<3, 3, T, P>( @@ -507,7 +507,7 @@ namespace glm m[2] / scalar); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator/(T scalar, mat<3, 3, T, P> const & m) { return mat<3, 3, T, P>( @@ -516,19 +516,19 @@ namespace glm scalar / m[2]); } - template + template GLM_FUNC_QUALIFIER typename mat<3, 3, T, P>::col_type operator/(mat<3, 3, T, P> const & m, typename mat<3, 3, T, P>::row_type const & v) { return inverse(m) * v; } - template + template GLM_FUNC_QUALIFIER typename mat<3, 3, T, P>::row_type operator/(typename mat<3, 3, T, P>::col_type const & v, mat<3, 3, T, P> const & m) { return v * inverse(m); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator/(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2) { mat<3, 3, T, P> m1_copy(m1); @@ -537,13 +537,13 @@ namespace glm // -- Boolean operators -- - template + template GLM_FUNC_QUALIFIER bool operator==(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]); } - template + template GLM_FUNC_QUALIFIER bool operator!=(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]); diff --git a/glm/detail/type_mat3x4.hpp b/glm/detail/type_mat3x4.hpp index 0cb50202..99cbf7f4 100644 --- a/glm/detail/type_mat3x4.hpp +++ b/glm/detail/type_mat3x4.hpp @@ -12,7 +12,7 @@ namespace glm { - template + template struct mat<3, 4, T, P> { typedef vec<4, T, P> col_type; @@ -37,7 +37,7 @@ namespace glm GLM_FUNC_DECL mat() GLM_DEFAULT; GLM_FUNC_DECL mat(mat<3, 4, T, P> const & m) GLM_DEFAULT; - template + template GLM_FUNC_DECL mat(mat<3, 4, T, Q> const & m); GLM_FUNC_DECL explicit mat(T scalar); @@ -69,7 +69,7 @@ namespace glm // -- Matrix conversions -- - template + template GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 4, U, Q> const & m); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x); @@ -110,59 +110,59 @@ namespace glm // -- Unary operators -- - template + template GLM_FUNC_DECL mat<3, 4, T, P> operator+(mat<3, 4, T, P> const & m); - template + template GLM_FUNC_DECL mat<3, 4, T, P> operator-(mat<3, 4, T, P> const & m); // -- Binary operators -- - template + template GLM_FUNC_DECL mat<3, 4, T, P> operator+(mat<3, 4, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<3, 4, T, P> operator+(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2); - template + template GLM_FUNC_DECL mat<3, 4, T, P> operator-(mat<3, 4, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<3, 4, T, P> operator-(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2); - template + template GLM_FUNC_DECL mat<3, 4, T, P> operator*(mat<3, 4, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<3, 4, T, P> operator*(T scalar, mat<3, 4, T, P> const & m); - template + template GLM_FUNC_DECL typename mat<3, 4, T, P>::col_type operator*(mat<3, 4, T, P> const & m, typename mat<3, 4, T, P>::row_type const & v); - template + template GLM_FUNC_DECL typename mat<3, 4, T, P>::row_type operator*(typename mat<3, 4, T, P>::col_type const & v, mat<3, 4, T, P> const & m); - template + template GLM_FUNC_DECL mat<4, 4, T, P> operator*(mat<3, 4, T, P> const & m1, mat<4, 3, T, P> const& m2); - template + template GLM_FUNC_DECL mat<2, 4, T, P> operator*(mat<3, 4, T, P> const & m1, mat<2, 3, T, P> const & m2); - template + template GLM_FUNC_DECL mat<3, 4, T, P> operator*(mat<3, 4, T, P> const & m1, mat<3, 3, T, P> const& m2); - template + template GLM_FUNC_DECL mat<3, 4, T, P> operator/(mat<3, 4, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<3, 4, T, P> operator/(T scalar, mat<3, 4, T, P> const & m); // -- Boolean operators -- - template + template GLM_FUNC_DECL bool operator==(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2); - template + template GLM_FUNC_DECL bool operator!=(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2); }//namespace glm diff --git a/glm/detail/type_mat3x4.inl b/glm/detail/type_mat3x4.inl index bd9008f9..f8c8de06 100644 --- a/glm/detail/type_mat3x4.inl +++ b/glm/detail/type_mat3x4.inl @@ -6,13 +6,13 @@ namespace glm // -- Constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat() {} # endif # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<3, 4, T, P> const & m) { this->value[0] = m.value[0]; @@ -21,8 +21,8 @@ namespace glm } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template - template + template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<3, 4, T, Q> const & m) { this->value[0] = m.value[0]; @@ -30,7 +30,7 @@ namespace glm this->value[2] = m.value[2]; } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(T scalar) { this->value[0] = col_type(scalar, 0, 0, 0); @@ -38,7 +38,7 @@ namespace glm this->value[2] = col_type(0, 0, scalar, 0); } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat ( T x0, T y0, T z0, T w0, @@ -51,7 +51,7 @@ namespace glm this->value[2] = col_type(x2, y2, z2, w2); } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat ( col_type const & v0, @@ -66,7 +66,7 @@ namespace glm // -- Conversion constructors -- - template + template template< typename X1, typename Y1, typename Z1, typename W1, typename X2, typename Y2, typename Z2, typename W2, @@ -83,7 +83,7 @@ namespace glm this->value[2] = col_type(static_cast(x3), value_type(y3), value_type(z3), value_type(w3)); } - template + template template GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat ( @@ -99,8 +99,8 @@ namespace glm // -- Matrix conversions -- - template - template + template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<3, 4, U, Q> const & m) { this->value[0] = col_type(m[0]); @@ -108,7 +108,7 @@ namespace glm this->value[2] = col_type(m[2]); } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<2, 2, T, P> const & m) { this->value[0] = col_type(m[0], 0, 0); @@ -116,7 +116,7 @@ namespace glm this->value[2] = col_type(0, 0, 1, 0); } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<3, 3, T, P> const & m) { this->value[0] = col_type(m[0], 0); @@ -124,7 +124,7 @@ namespace glm this->value[2] = col_type(m[2], 0); } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<4, 4, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -132,7 +132,7 @@ namespace glm this->value[2] = col_type(m[2]); } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<2, 3, T, P> const & m) { this->value[0] = col_type(m[0], 0); @@ -140,7 +140,7 @@ namespace glm this->value[2] = col_type(0, 0, 1, 0); } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<3, 2, T, P> const & m) { this->value[0] = col_type(m[0], 0, 0); @@ -148,7 +148,7 @@ namespace glm this->value[2] = col_type(m[2], 1, 0); } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<2, 4, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -156,7 +156,7 @@ namespace glm this->value[2] = col_type(0, 0, 1, 0); } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<4, 2, T, P> const & m) { this->value[0] = col_type(m[0], 0, 0); @@ -164,7 +164,7 @@ namespace glm this->value[2] = col_type(m[2], 1, 0); } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<4, 3, T, P> const & m) { this->value[0] = col_type(m[0], 0); @@ -174,14 +174,14 @@ namespace glm // -- Accesses -- - template + template GLM_FUNC_QUALIFIER typename mat<3, 4, T, P>::col_type & mat<3, 4, T, P>::operator[](typename mat<3, 4, T, P>::length_type i) { assert(i < this->length()); return this->value[i]; } - template + template GLM_FUNC_QUALIFIER typename mat<3, 4, T, P>::col_type const & mat<3, 4, T, P>::operator[](typename mat<3, 4, T, P>::length_type i) const { assert(i < this->length()); @@ -191,7 +191,7 @@ namespace glm // -- Unary updatable operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator=(mat<3, 4, T, P> const & m) { this->value[0] = m[0]; @@ -201,7 +201,7 @@ namespace glm } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template + template template GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator=(mat<3, 4, U, P> const & m) { @@ -211,7 +211,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator+=(U s) { @@ -221,7 +221,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator+=(mat<3, 4, U, P> const & m) { @@ -231,7 +231,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator-=(U s) { @@ -241,7 +241,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator-=(mat<3, 4, U, P> const & m) { @@ -251,7 +251,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator*=(U s) { @@ -261,7 +261,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<3, 4, T, P> & mat<3, 4, T, P>::operator/=(U s) { @@ -273,7 +273,7 @@ namespace glm // -- Increment and decrement operators -- - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator++() { ++this->value[0]; @@ -282,7 +282,7 @@ namespace glm return *this; } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator--() { --this->value[0]; @@ -291,7 +291,7 @@ namespace glm return *this; } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P> mat<3, 4, T, P>::operator++(int) { mat<3, 4, T, P> Result(*this); @@ -299,7 +299,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P> mat<3, 4, T, P>::operator--(int) { mat<3, 4, T, P> Result(*this); @@ -309,13 +309,13 @@ namespace glm // -- Unary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator+(mat<3, 4, T, P> const & m) { return m; } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator-(mat<3, 4, T, P> const & m) { return mat<3, 4, T, P>( @@ -326,7 +326,7 @@ namespace glm // -- Binary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator+(mat<3, 4, T, P> const & m, T scalar) { return mat<3, 4, T, P>( @@ -335,7 +335,7 @@ namespace glm m[2] + scalar); } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator+(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2) { return mat<3, 4, T, P>( @@ -344,7 +344,7 @@ namespace glm m1[2] + m2[2]); } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator-(mat<3, 4, T, P> const & m, T scalar) { return mat<3, 4, T, P>( @@ -353,7 +353,7 @@ namespace glm m[2] - scalar); } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator-(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2) { return mat<3, 4, T, P>( @@ -362,7 +362,7 @@ namespace glm m1[2] - m2[2]); } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator*(mat<3, 4, T, P> const & m, T scalar) { return mat<3, 4, T, P>( @@ -371,7 +371,7 @@ namespace glm m[2] * scalar); } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator*(T scalar, mat<3, 4, T, P> const & m) { return mat<3, 4, T, P>( @@ -380,7 +380,7 @@ namespace glm m[2] * scalar); } - template + template GLM_FUNC_QUALIFIER typename mat<3, 4, T, P>::col_type operator* ( mat<3, 4, T, P> const& m, @@ -394,7 +394,7 @@ namespace glm m[0][3] * v.x + m[1][3] * v.y + m[2][3] * v.z); } - template + template GLM_FUNC_QUALIFIER typename mat<3, 4, T, P>::row_type operator* ( typename mat<3, 4, T, P>::col_type const & v, @@ -407,7 +407,7 @@ namespace glm v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2] + v.w * m[2][3]); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator*(mat<3, 4, T, P> const & m1, mat<4, 3, T, P> const & m2) { const T SrcA00 = m1[0][0]; @@ -456,7 +456,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator*(mat<3, 4, T, P> const & m1, mat<2, 3, T, P> const & m2) { return mat<2, 4, T, P>( @@ -470,7 +470,7 @@ namespace glm m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2]); } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator*(mat<3, 4, T, P> const & m1, mat<3, 3, T, P> const & m2) { return mat<3, 4, T, P>( @@ -488,7 +488,7 @@ namespace glm m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2]); } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator/(mat<3, 4, T, P> const & m, T scalar) { return mat<3, 4, T, P>( @@ -497,7 +497,7 @@ namespace glm m[2] / scalar); } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator/(T scalar, mat<3, 4, T, P> const & m) { return mat<3, 4, T, P>( @@ -508,13 +508,13 @@ namespace glm // -- Boolean operators -- - template + template GLM_FUNC_QUALIFIER bool operator==(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]); } - template + template GLM_FUNC_QUALIFIER bool operator!=(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]); diff --git a/glm/detail/type_mat4x2.hpp b/glm/detail/type_mat4x2.hpp index 3390b2f7..88575dc0 100644 --- a/glm/detail/type_mat4x2.hpp +++ b/glm/detail/type_mat4x2.hpp @@ -12,7 +12,7 @@ namespace glm { - template + template struct mat<4, 2, T, P> { typedef vec<2, T, P> col_type; @@ -37,7 +37,7 @@ namespace glm GLM_FUNC_DECL mat() GLM_DEFAULT; GLM_FUNC_DECL mat(mat<4, 2, T, P> const & m) GLM_DEFAULT; - template + template GLM_FUNC_DECL mat(mat<4, 2, T, Q> const & m); GLM_FUNC_DECL explicit mat(T scalar); @@ -74,7 +74,7 @@ namespace glm // -- Matrix conversions -- - template + template GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 2, U, Q> const & m); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x); @@ -115,59 +115,59 @@ namespace glm // -- Unary operators -- - template + template GLM_FUNC_DECL mat<4, 2, T, P> operator+(mat<4, 2, T, P> const & m); - template + template GLM_FUNC_DECL mat<4, 2, T, P> operator-(mat<4, 2, T, P> const & m); // -- Binary operators -- - template + template GLM_FUNC_DECL mat<4, 2, T, P> operator+(mat<4, 2, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<4, 2, T, P> operator+(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const & m2); - template + template GLM_FUNC_DECL mat<4, 2, T, P> operator-(mat<4, 2, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<4, 2, T, P> operator-(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const& m2); - template + template GLM_FUNC_DECL mat<4, 2, T, P> operator*(mat<4, 2, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<4, 2, T, P> operator*(T scalar, mat<4, 2, T, P> const & m); - template + template GLM_FUNC_DECL typename mat<4, 2, T, P>::col_type operator*(mat<4, 2, T, P> const & m, typename mat<4, 2, T, P>::row_type const & v); - template + template GLM_FUNC_DECL typename mat<4, 2, T, P>::row_type operator*(typename mat<4, 2, T, P>::col_type const & v, mat<4, 2, T, P> const & m); - template + template GLM_FUNC_DECL mat<2, 2, T, P> operator*(mat<4, 2, T, P> const & m1, mat<2, 4, T, P> const & m2); - template + template GLM_FUNC_DECL mat<3, 2, T, P> operator*(mat<4, 2, T, P> const & m1, mat<3, 4, T, P> const & m2); - template + template GLM_FUNC_DECL mat<4, 2, T, P> operator*(mat<4, 2, T, P> const & m1, mat<4, 4, T, P> const & m2); - template + template GLM_FUNC_DECL mat<4, 2, T, P> operator/(mat<4, 2, T, P> const & m, T scalar); - template + template GLM_FUNC_DECL mat<4, 2, T, P> operator/(T scalar, mat<4, 2, T, P> const & m); // -- Boolean operators -- - template + template GLM_FUNC_DECL bool operator==(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const & m2); - template + template GLM_FUNC_DECL bool operator!=(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const & m2); }//namespace glm diff --git a/glm/detail/type_mat4x2.inl b/glm/detail/type_mat4x2.inl index 1998b97e..9df56ed9 100644 --- a/glm/detail/type_mat4x2.inl +++ b/glm/detail/type_mat4x2.inl @@ -6,13 +6,13 @@ namespace glm // -- Constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat() {} # endif # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<4, 2, T, P> const & m) { this->value[0] = m.value[0]; @@ -22,8 +22,8 @@ namespace glm } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template - template + template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<4, 2, T, Q> const & m) { this->value[0] = m.value[0]; @@ -32,7 +32,7 @@ namespace glm this->value[3] = m.value[3]; } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(T scalar) { this->value[0] = col_type(scalar, 0); @@ -41,7 +41,7 @@ namespace glm this->value[3] = col_type(0, 0); } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat ( T x0, T y0, @@ -56,7 +56,7 @@ namespace glm this->value[3] = col_type(x3, y3); } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat ( col_type const & v0, @@ -73,7 +73,7 @@ namespace glm // -- Conversion constructors -- - template + template template< typename X1, typename Y1, typename X2, typename Y2, @@ -93,7 +93,7 @@ namespace glm this->value[3] = col_type(static_cast(x4), value_type(y4)); } - template + template template GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat ( @@ -111,8 +111,8 @@ namespace glm // -- Conversion -- - template - template + template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<4, 2, U, Q> const & m) { this->value[0] = col_type(m[0]); @@ -121,7 +121,7 @@ namespace glm this->value[3] = col_type(m[3]); } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<2, 2, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -130,7 +130,7 @@ namespace glm this->value[3] = col_type(0); } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<3, 3, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -139,7 +139,7 @@ namespace glm this->value[3] = col_type(0); } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<4, 4, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -148,7 +148,7 @@ namespace glm this->value[3] = col_type(m[3]); } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<2, 3, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -157,7 +157,7 @@ namespace glm this->value[3] = col_type(0); } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<3, 2, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -166,7 +166,7 @@ namespace glm this->value[3] = col_type(0); } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<2, 4, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -175,7 +175,7 @@ namespace glm this->value[3] = col_type(0); } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<4, 3, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -184,7 +184,7 @@ namespace glm this->value[3] = col_type(m[3]); } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<3, 4, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -195,14 +195,14 @@ namespace glm // -- Accesses -- - template + template GLM_FUNC_QUALIFIER typename mat<4, 2, T, P>::col_type & mat<4, 2, T, P>::operator[](typename mat<4, 2, T, P>::length_type i) { assert(i < this->length()); return this->value[i]; } - template + template GLM_FUNC_QUALIFIER typename mat<4, 2, T, P>::col_type const & mat<4, 2, T, P>::operator[](typename mat<4, 2, T, P>::length_type i) const { assert(i < this->length()); @@ -212,7 +212,7 @@ namespace glm // -- Unary updatable operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P>& mat<4, 2, T, P>::operator=(mat<4, 2, T, P> const & m) { this->value[0] = m[0]; @@ -223,7 +223,7 @@ namespace glm } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template + template template GLM_FUNC_QUALIFIER mat<4, 2, T, P>& mat<4, 2, T, P>::operator=(mat<4, 2, U, P> const & m) { @@ -234,7 +234,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator+=(U s) { @@ -245,7 +245,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator+=(mat<4, 2, U, P> const & m) { @@ -256,7 +256,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator-=(U s) { @@ -267,7 +267,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator-=(mat<4, 2, U, P> const & m) { @@ -278,7 +278,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator*=(U s) { @@ -289,7 +289,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator/=(U s) { @@ -302,7 +302,7 @@ namespace glm // -- Increment and decrement operators -- - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator++() { ++this->value[0]; @@ -312,7 +312,7 @@ namespace glm return *this; } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator--() { --this->value[0]; @@ -322,7 +322,7 @@ namespace glm return *this; } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P> mat<4, 2, T, P>::operator++(int) { mat<4, 2, T, P> Result(*this); @@ -330,7 +330,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P> mat<4, 2, T, P>::operator--(int) { mat<4, 2, T, P> Result(*this); @@ -340,13 +340,13 @@ namespace glm // -- Unary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator+(mat<4, 2, T, P> const & m) { return m; } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator-(mat<4, 2, T, P> const & m) { return mat<4, 2, T, P>( @@ -358,7 +358,7 @@ namespace glm // -- Binary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator+(mat<4, 2, T, P> const & m, T scalar) { return mat<4, 2, T, P>( @@ -368,7 +368,7 @@ namespace glm m[3] + scalar); } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator+(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const & m2) { return mat<4, 2, T, P>( @@ -378,7 +378,7 @@ namespace glm m1[3] + m2[3]); } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator-(mat<4, 2, T, P> const & m, T scalar) { return mat<4, 2, T, P>( @@ -388,7 +388,7 @@ namespace glm m[3] - scalar); } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator-(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const & m2) { return mat<4, 2, T, P>( @@ -398,7 +398,7 @@ namespace glm m1[3] - m2[3]); } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator*(mat<4, 2, T, P> const & m, T scalar) { return mat<4, 2, T, P>( @@ -408,7 +408,7 @@ namespace glm m[3] * scalar); } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator*(T scalar, mat<4, 2, T, P> const & m) { return mat<4, 2, T, P>( @@ -418,7 +418,7 @@ namespace glm m[3] * scalar); } - template + template GLM_FUNC_QUALIFIER typename mat<4, 2, T, P>::col_type operator*(mat<4, 2, T, P> const & m, typename mat<4, 2, T, P>::row_type const & v) { return typename mat<4, 2, T, P>::col_type( @@ -426,7 +426,7 @@ namespace glm m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w); } - template + template GLM_FUNC_QUALIFIER typename mat<4, 2, T, P>::row_type operator*(typename mat<4, 2, T, P>::col_type const & v, mat<4, 2, T, P> const & m) { return typename mat<4, 2, T, P>::row_type( @@ -436,7 +436,7 @@ namespace glm v.x * m[3][0] + v.y * m[3][1]); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator*(mat<4, 2, T, P> const & m1, mat<2, 4, T, P> const & m2) { T const SrcA00 = m1[0][0]; @@ -465,7 +465,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator*(mat<4, 2, T, P> const & m1, mat<3, 4, T, P> const & m2) { return mat<3, 2, T, P>( @@ -477,7 +477,7 @@ namespace glm m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3]); } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator*(mat<4, 2, T, P> const & m1, mat<4, 4, T, P> const & m2) { return mat<4, 2, T, P>( @@ -491,7 +491,7 @@ namespace glm m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2] + m1[3][1] * m2[3][3]); } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator/(mat<4, 2, T, P> const & m, T scalar) { return mat<4, 2, T, P>( @@ -501,7 +501,7 @@ namespace glm m[3] / scalar); } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator/(T scalar, mat<4, 2, T, P> const & m) { return mat<4, 2, T, P>( @@ -513,13 +513,13 @@ namespace glm // -- Boolean operators -- - template + template GLM_FUNC_QUALIFIER bool operator==(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const & m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]); } - template + template GLM_FUNC_QUALIFIER bool operator!=(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const & m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]); diff --git a/glm/detail/type_mat4x3.hpp b/glm/detail/type_mat4x3.hpp index 47cc1333..4bc530ba 100644 --- a/glm/detail/type_mat4x3.hpp +++ b/glm/detail/type_mat4x3.hpp @@ -12,7 +12,7 @@ namespace glm { - template + template struct mat<4, 3, T, P> { typedef vec<3, T, P> col_type; @@ -37,7 +37,7 @@ namespace glm GLM_FUNC_DECL mat() GLM_DEFAULT; GLM_FUNC_DECL mat(mat<4, 3, T, P> const & m) GLM_DEFAULT; - template + template GLM_FUNC_DECL mat(mat<4, 3, T, Q> const & m); GLM_FUNC_DECL explicit mat(T const & x); @@ -74,7 +74,7 @@ namespace glm // -- Matrix conversions -- - template + template GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 3, U, Q> const & m); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x); @@ -115,59 +115,59 @@ namespace glm // -- Unary operators -- - template + template GLM_FUNC_DECL mat<4, 3, T, P> operator+(mat<4, 3, T, P> const & m); - template + template GLM_FUNC_DECL mat<4, 3, T, P> operator-(mat<4, 3, T, P> const & m); // -- Binary operators -- - template + template GLM_FUNC_DECL mat<4, 3, T, P> operator+(mat<4, 3, T, P> const & m, T const & s); - template + template GLM_FUNC_DECL mat<4, 3, T, P> operator+(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2); - template + template GLM_FUNC_DECL mat<4, 3, T, P> operator-(mat<4, 3, T, P> const & m, T const & s); - template + template GLM_FUNC_DECL mat<4, 3, T, P> operator-(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2); - template + template GLM_FUNC_DECL mat<4, 3, T, P> operator*(mat<4, 3, T, P> const & m, T const & s); - template + template GLM_FUNC_DECL mat<4, 3, T, P> operator*(T const & s, mat<4, 3, T, P> const & m); - template + template GLM_FUNC_DECL typename mat<4, 3, T, P>::col_type operator*(mat<4, 3, T, P> const & m, typename mat<4, 3, T, P>::row_type const & v); - template + template GLM_FUNC_DECL typename mat<4, 3, T, P>::row_type operator*(typename mat<4, 3, T, P>::col_type const & v, mat<4, 3, T, P> const & m); - template + template GLM_FUNC_DECL mat<2, 3, T, P> operator*(mat<4, 3, T, P> const & m1, mat<2, 4, T, P> const & m2); - template + template GLM_FUNC_DECL mat<3, 3, T, P> operator*(mat<4, 3, T, P> const & m1, mat<3, 4, T, P> const& m2); - template + template GLM_FUNC_DECL mat<4, 3, T, P> operator*(mat<4, 3, T, P> const & m1, mat<4, 4, T, P> const & m2); - template + template GLM_FUNC_DECL mat<4, 3, T, P> operator/(mat<4, 3, T, P> const & m, T const & s); - template + template GLM_FUNC_DECL mat<4, 3, T, P> operator/(T const & s, mat<4, 3, T, P> const & m); // -- Boolean operators -- - template + template GLM_FUNC_DECL bool operator==(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2); - template + template GLM_FUNC_DECL bool operator!=(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2); }//namespace glm diff --git a/glm/detail/type_mat4x3.inl b/glm/detail/type_mat4x3.inl index 0492c32c..a72d2675 100644 --- a/glm/detail/type_mat4x3.inl +++ b/glm/detail/type_mat4x3.inl @@ -6,13 +6,13 @@ namespace glm // -- Constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat() {} # endif # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<4, 3, T, P> const & m) { this->value[0] = m.value[0]; @@ -22,8 +22,8 @@ namespace glm } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template - template + template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<4, 3, T, Q> const & m) { this->value[0] = m.value[0]; @@ -32,7 +32,7 @@ namespace glm this->value[3] = m.value[3]; } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(T const & s) { this->value[0] = col_type(s, 0, 0); @@ -41,7 +41,7 @@ namespace glm this->value[3] = col_type(0, 0, 0); } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat ( T const & x0, T const & y0, T const & z0, @@ -56,7 +56,7 @@ namespace glm this->value[3] = col_type(x3, y3, z3); } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat ( col_type const & v0, @@ -73,7 +73,7 @@ namespace glm // -- Conversion constructors -- - template + template template< typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2, @@ -93,7 +93,7 @@ namespace glm this->value[3] = col_type(static_cast(x4), value_type(y4), value_type(z4)); } - template + template template GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat ( @@ -111,8 +111,8 @@ namespace glm // -- Matrix conversions -- - template - template + template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<4, 3, U, Q> const & m) { this->value[0] = col_type(m[0]); @@ -121,7 +121,7 @@ namespace glm this->value[3] = col_type(m[3]); } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<2, 2, T, P> const & m) { this->value[0] = col_type(m[0], 0); @@ -130,7 +130,7 @@ namespace glm this->value[3] = col_type(0); } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<3, 3, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -139,7 +139,7 @@ namespace glm this->value[3] = col_type(0); } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<4, 4, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -148,7 +148,7 @@ namespace glm this->value[3] = col_type(m[3]); } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<2, 3, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -157,7 +157,7 @@ namespace glm this->value[3] = col_type(0); } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<3, 2, T, P> const & m) { this->value[0] = col_type(m[0], 0); @@ -166,7 +166,7 @@ namespace glm this->value[3] = col_type(0); } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<2, 4, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -175,7 +175,7 @@ namespace glm this->value[3] = col_type(0); } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<4, 2, T, P> const & m) { this->value[0] = col_type(m[0], 0); @@ -184,7 +184,7 @@ namespace glm this->value[3] = col_type(m[3], 0); } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<3, 4, T, P> const & m) { this->value[0] = col_type(m[0]); @@ -195,14 +195,14 @@ namespace glm // -- Accesses -- - template + template GLM_FUNC_QUALIFIER typename mat<4, 3, T, P>::col_type & mat<4, 3, T, P>::operator[](typename mat<4, 3, T, P>::length_type i) { assert(i < this->length()); return this->value[i]; } - template + template GLM_FUNC_QUALIFIER typename mat<4, 3, T, P>::col_type const & mat<4, 3, T, P>::operator[](typename mat<4, 3, T, P>::length_type i) const { assert(i < this->length()); @@ -212,7 +212,7 @@ namespace glm // -- Unary updatable operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P>& mat<4, 3, T, P>::operator=(mat<4, 3, T, P> const & m) { this->value[0] = m[0]; @@ -223,7 +223,7 @@ namespace glm } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template + template template GLM_FUNC_QUALIFIER mat<4, 3, T, P>& mat<4, 3, T, P>::operator=(mat<4, 3, U, P> const & m) { @@ -234,7 +234,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator+=(U s) { @@ -245,7 +245,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator+=(mat<4, 3, U, P> const & m) { @@ -256,7 +256,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator-=(U s) { @@ -267,7 +267,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator-=(mat<4, 3, U, P> const & m) { @@ -278,7 +278,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator*=(U s) { @@ -289,7 +289,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator/=(U s) { @@ -302,7 +302,7 @@ namespace glm // -- Increment and decrement operators -- - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator++() { ++this->value[0]; @@ -312,7 +312,7 @@ namespace glm return *this; } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator--() { --this->value[0]; @@ -322,7 +322,7 @@ namespace glm return *this; } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P> mat<4, 3, T, P>::operator++(int) { mat<4, 3, T, P> Result(*this); @@ -330,7 +330,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P> mat<4, 3, T, P>::operator--(int) { mat<4, 3, T, P> Result(*this); @@ -340,13 +340,13 @@ namespace glm // -- Unary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator+(mat<4, 3, T, P> const & m) { return m; } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator-(mat<4, 3, T, P> const & m) { return mat<4, 3, T, P>( @@ -358,7 +358,7 @@ namespace glm // -- Binary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator+(mat<4, 3, T, P> const & m, T const & s) { return mat<4, 3, T, P>( @@ -368,7 +368,7 @@ namespace glm m[3] + s); } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator+(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2) { return mat<4, 3, T, P>( @@ -378,7 +378,7 @@ namespace glm m1[3] + m2[3]); } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator-(mat<4, 3, T, P> const & m, T const & s) { return mat<4, 3, T, P>( @@ -388,7 +388,7 @@ namespace glm m[3] - s); } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator-(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2) { return mat<4, 3, T, P>( @@ -398,7 +398,7 @@ namespace glm m1[3] - m2[3]); } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator*(mat<4, 3, T, P> const & m, T const & s) { return mat<4, 3, T, P>( @@ -408,7 +408,7 @@ namespace glm m[3] * s); } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator*(T const & s, mat<4, 3, T, P> const & m) { return mat<4, 3, T, P>( @@ -418,7 +418,7 @@ namespace glm m[3] * s); } - template + template GLM_FUNC_QUALIFIER typename mat<4, 3, T, P>::col_type operator* ( mat<4, 3, T, P> const& m, @@ -430,7 +430,7 @@ namespace glm m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z + m[3][2] * v.w); } - template + template GLM_FUNC_QUALIFIER typename mat<4, 3, T, P>::row_type operator* ( typename mat<4, 3, T, P>::col_type const & v, @@ -443,7 +443,7 @@ namespace glm v.x * m[3][0] + v.y * m[3][1] + v.z * m[3][2]); } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator*(mat<4, 3, T, P> const & m1, mat<2, 4, T, P> const & m2) { return mat<2, 3, T, P>( @@ -455,7 +455,7 @@ namespace glm m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3]); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator*(mat<4, 3, T, P> const & m1, mat<3, 4, T, P> const & m2) { T const SrcA00 = m1[0][0]; @@ -497,7 +497,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator*(mat<4, 3, T, P> const & m1, mat<4, 4, T, P> const & m2) { return mat<4, 3, T, P>( @@ -515,7 +515,7 @@ namespace glm m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2] + m1[3][2] * m2[3][3]); } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator/(mat<4, 3, T, P> const & m, T const & s) { return mat<4, 3, T, P>( @@ -525,7 +525,7 @@ namespace glm m[3] / s); } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator/(T const & s, mat<4, 3, T, P> const & m) { return mat<4, 3, T, P>( @@ -537,13 +537,13 @@ namespace glm // -- Boolean operators -- - template + template GLM_FUNC_QUALIFIER bool operator==(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]); } - template + template GLM_FUNC_QUALIFIER bool operator!=(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]); diff --git a/glm/detail/type_mat4x4.hpp b/glm/detail/type_mat4x4.hpp index 9c7133b4..04a8d7a3 100644 --- a/glm/detail/type_mat4x4.hpp +++ b/glm/detail/type_mat4x4.hpp @@ -11,7 +11,7 @@ namespace glm { - template + template struct mat<4, 4, T, P> { typedef vec<4, T, P> col_type; @@ -36,7 +36,7 @@ namespace glm GLM_FUNC_DECL mat() GLM_DEFAULT; GLM_FUNC_DECL mat(mat<4, 4, T, P> const& m) GLM_DEFAULT; - template + template GLM_FUNC_DECL mat(mat<4, 4, T, Q> const& m); GLM_FUNC_DECL explicit mat(T const & x); @@ -73,7 +73,7 @@ namespace glm // -- Matrix conversions -- - template + template GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 4, U, Q> const & m); GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x); @@ -118,74 +118,74 @@ namespace glm // -- Unary operators -- - template + template GLM_FUNC_DECL mat<4, 4, T, P> operator+(mat<4, 4, T, P> const & m); - template + template GLM_FUNC_DECL mat<4, 4, T, P> operator-(mat<4, 4, T, P> const & m); // -- Binary operators -- - template + template GLM_FUNC_DECL mat<4, 4, T, P> operator+(mat<4, 4, T, P> const & m, T const & s); - template + template GLM_FUNC_DECL mat<4, 4, T, P> operator+(T const & s, mat<4, 4, T, P> const & m); - template + template GLM_FUNC_DECL mat<4, 4, T, P> operator+(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2); - template + template GLM_FUNC_DECL mat<4, 4, T, P> operator-(mat<4, 4, T, P> const & m, T const & s); - template + template GLM_FUNC_DECL mat<4, 4, T, P> operator-(T const & s, mat<4, 4, T, P> const & m); - template + template GLM_FUNC_DECL mat<4, 4, T, P> operator-(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const& m2); - template + template GLM_FUNC_DECL mat<4, 4, T, P> operator*(mat<4, 4, T, P> const & m, T const & s); - template + template GLM_FUNC_DECL mat<4, 4, T, P> operator*(T const & s, mat<4, 4, T, P> const & m); - template + template GLM_FUNC_DECL typename mat<4, 4, T, P>::col_type operator*(mat<4, 4, T, P> const & m, typename mat<4, 4, T, P>::row_type const & v); - template + template GLM_FUNC_DECL typename mat<4, 4, T, P>::row_type operator*(typename mat<4, 4, T, P>::col_type const & v, mat<4, 4, T, P> const & m); - template + template GLM_FUNC_DECL mat<2, 4, T, P> operator*(mat<4, 4, T, P> const & m1, mat<2, 4, T, P> const & m2); - template + template GLM_FUNC_DECL mat<3, 4, T, P> operator*(mat<4, 4, T, P> const & m1, mat<3, 4, T, P> const & m2); - template + template GLM_FUNC_DECL mat<4, 4, T, P> operator*(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2); - template + template GLM_FUNC_DECL mat<4, 4, T, P> operator/(mat<4, 4, T, P> const & m, T const & s); - template + template GLM_FUNC_DECL mat<4, 4, T, P> operator/(T const & s, mat<4, 4, T, P> const & m); - template + template GLM_FUNC_DECL typename mat<4, 4, T, P>::col_type operator/(mat<4, 4, T, P> const & m, typename mat<4, 4, T, P>::row_type const & v); - template + template GLM_FUNC_DECL typename mat<4, 4, T, P>::row_type operator/(typename mat<4, 4, T, P>::col_type const & v, mat<4, 4, T, P> const & m); - template + template GLM_FUNC_DECL mat<4, 4, T, P> operator/(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const& m2); // -- Boolean operators -- - template + template GLM_FUNC_DECL bool operator==(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2); - template + template GLM_FUNC_DECL bool operator!=(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2); }//namespace glm diff --git a/glm/detail/type_mat4x4.inl b/glm/detail/type_mat4x4.inl index 2e05f9f7..f665937e 100644 --- a/glm/detail/type_mat4x4.inl +++ b/glm/detail/type_mat4x4.inl @@ -8,13 +8,13 @@ namespace glm // -- Constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat() {} # endif # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<4, 4, T, P> const & m) { this->value[0] = m[0]; @@ -24,8 +24,8 @@ namespace glm } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template - template + template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<4, 4, T, Q> const & m) { this->value[0] = m[0]; @@ -34,7 +34,7 @@ namespace glm this->value[3] = m[3]; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(T const & s) { this->value[0] = col_type(s, 0, 0, 0); @@ -43,7 +43,7 @@ namespace glm this->value[3] = col_type(0, 0, 0, s); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat ( T const & x0, T const & y0, T const & z0, T const & w0, @@ -58,7 +58,7 @@ namespace glm this->value[3] = col_type(x3, y3, z3, w3); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat ( col_type const & v0, @@ -73,8 +73,8 @@ namespace glm this->value[3] = v3; } - template - template + template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat ( mat<4, 4, U, Q> const & m @@ -88,7 +88,7 @@ namespace glm // -- Conversions -- - template + template template< typename X1, typename Y1, typename Z1, typename W1, typename X2, typename Y2, typename Z2, typename W2, @@ -128,7 +128,7 @@ namespace glm this->value[3] = col_type(static_cast(x4), value_type(y4), value_type(z4), value_type(w4)); } - template + template template GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat ( @@ -151,7 +151,7 @@ namespace glm // -- Matrix conversions -- - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<2, 2, T, P> const & m) { this->value[0] = col_type(m[0], 0, 0); @@ -160,7 +160,7 @@ namespace glm this->value[3] = col_type(0, 0, 0, 1); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<3, 3, T, P> const & m) { this->value[0] = col_type(m[0], 0); @@ -169,7 +169,7 @@ namespace glm this->value[3] = col_type(0, 0, 0, 1); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<2, 3, T, P> const & m) { this->value[0] = col_type(m[0], 0); @@ -178,7 +178,7 @@ namespace glm this->value[3] = col_type(0, 0, 0, 1); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<3, 2, T, P> const & m) { this->value[0] = col_type(m[0], 0, 0); @@ -187,7 +187,7 @@ namespace glm this->value[3] = col_type(0, 0, 0, 1); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<2, 4, T, P> const & m) { this->value[0] = m[0]; @@ -196,7 +196,7 @@ namespace glm this->value[3] = col_type(0, 0, 0, 1); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<4, 2, T, P> const & m) { this->value[0] = col_type(m[0], 0, 0); @@ -205,7 +205,7 @@ namespace glm this->value[3] = col_type(0, 0, 0, 1); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<3, 4, T, P> const & m) { this->value[0] = m[0]; @@ -214,7 +214,7 @@ namespace glm this->value[3] = col_type(0, 0, 0, 1); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<4, 3, T, P> const & m) { this->value[0] = col_type(m[0], 0); @@ -225,14 +225,14 @@ namespace glm // -- Accesses -- - template + template GLM_FUNC_QUALIFIER typename mat<4, 4, T, P>::col_type & mat<4, 4, T, P>::operator[](typename mat<4, 4, T, P>::length_type i) { assert(i < this->length()); return this->value[i]; } - template + template GLM_FUNC_QUALIFIER typename mat<4, 4, T, P>::col_type const & mat<4, 4, T, P>::operator[](typename mat<4, 4, T, P>::length_type i) const { assert(i < this->length()); @@ -242,7 +242,7 @@ namespace glm // -- Unary arithmetic operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P>& mat<4, 4, T, P>::operator=(mat<4, 4, T, P> const & m) { //memcpy could be faster @@ -255,7 +255,7 @@ namespace glm } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template + template template GLM_FUNC_QUALIFIER mat<4, 4, T, P>& mat<4, 4, T, P>::operator=(mat<4, 4, U, P> const & m) { @@ -268,7 +268,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<4, 4, T, P>& mat<4, 4, T, P>::operator+=(U s) { @@ -279,7 +279,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<4, 4, T, P>& mat<4, 4, T, P>::operator+=(mat<4, 4, U, P> const & m) { @@ -290,7 +290,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator-=(U s) { @@ -301,7 +301,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator-=(mat<4, 4, U, P> const & m) { @@ -312,7 +312,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator*=(U s) { @@ -323,14 +323,14 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator*=(mat<4, 4, U, P> const & m) { return (*this = *this * m); } - template + template template GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator/=(U s) { @@ -341,7 +341,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator/=(mat<4, 4, U, P> const & m) { @@ -350,7 +350,7 @@ namespace glm // -- Increment and decrement operators -- - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator++() { ++this->value[0]; @@ -360,7 +360,7 @@ namespace glm return *this; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator--() { --this->value[0]; @@ -370,7 +370,7 @@ namespace glm return *this; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> mat<4, 4, T, P>::operator++(int) { mat<4, 4, T, P> Result(*this); @@ -378,7 +378,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> mat<4, 4, T, P>::operator--(int) { mat<4, 4, T, P> Result(*this); @@ -388,13 +388,13 @@ namespace glm // -- Unary constant operators -- - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator+(mat<4, 4, T, P> const & m) { return m; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator-(mat<4, 4, T, P> const & m) { return mat<4, 4, T, P>( @@ -406,7 +406,7 @@ namespace glm // -- Binary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator+(mat<4, 4, T, P> const & m, T const & s) { return mat<4, 4, T, P>( @@ -416,7 +416,7 @@ namespace glm m[3] + s); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator+(T const & s, mat<4, 4, T, P> const & m) { return mat<4, 4, T, P>( @@ -426,7 +426,7 @@ namespace glm m[3] + s); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator+(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2) { return mat<4, 4, T, P>( @@ -436,7 +436,7 @@ namespace glm m1[3] + m2[3]); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator-(mat<4, 4, T, P> const & m, T const & s) { return mat<4, 4, T, P>( @@ -446,7 +446,7 @@ namespace glm m[3] - s); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator-(T const & s, mat<4, 4, T, P> const & m) { return mat<4, 4, T, P>( @@ -456,7 +456,7 @@ namespace glm s - m[3]); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator-(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2) { return mat<4, 4, T, P>( @@ -466,7 +466,7 @@ namespace glm m1[3] - m2[3]); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator*(mat<4, 4, T, P> const & m, T const & s) { return mat<4, 4, T, P>( @@ -476,7 +476,7 @@ namespace glm m[3] * s); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator*(T const & s, mat<4, 4, T, P> const & m) { return mat<4, 4, T, P>( @@ -486,7 +486,7 @@ namespace glm m[3] * s); } - template + template GLM_FUNC_QUALIFIER typename mat<4, 4, T, P>::col_type operator* ( mat<4, 4, T, P> const& m, @@ -534,7 +534,7 @@ namespace glm */ } - template + template GLM_FUNC_QUALIFIER typename mat<4, 4, T, P>::row_type operator* ( typename mat<4, 4, T, P>::col_type const & v, @@ -548,7 +548,7 @@ namespace glm m[3][0] * v[0] + m[3][1] * v[1] + m[3][2] * v[2] + m[3][3] * v[3]); } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator*(mat<4, 4, T, P> const & m1, mat<2, 4, T, P> const & m2) { return mat<2, 4, T, P>( @@ -562,7 +562,7 @@ namespace glm m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2] + m1[3][3] * m2[1][3]); } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator*(mat<4, 4, T, P> const & m1, mat<3, 4, T, P> const & m2) { return mat<3, 4, T, P>( @@ -580,7 +580,7 @@ namespace glm m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2] + m1[3][3] * m2[2][3]); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator*(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2) { typename mat<4, 4, T, P>::col_type const SrcA0 = m1[0]; @@ -601,7 +601,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator/(mat<4, 4, T, P> const & m, T const & s) { return mat<4, 4, T, P>( @@ -611,7 +611,7 @@ namespace glm m[3] / s); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator/(T const & s, mat<4, 4, T, P> const& m) { return mat<4, 4, T, P>( @@ -621,19 +621,19 @@ namespace glm s / m[3]); } - template + template GLM_FUNC_QUALIFIER typename mat<4, 4, T, P>::col_type operator/(mat<4, 4, T, P> const & m, typename mat<4, 4, T, P>::row_type const & v) { return inverse(m) * v; } - template + template GLM_FUNC_QUALIFIER typename mat<4, 4, T, P>::row_type operator/(typename mat<4, 4, T, P>::col_type const & v, mat<4, 4, T, P> const & m) { return v * inverse(m); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator/(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2) { mat<4, 4, T, P> m1_copy(m1); @@ -642,13 +642,13 @@ namespace glm // -- Boolean operators -- - template + template GLM_FUNC_QUALIFIER bool operator==(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2) { return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]); } - template + template GLM_FUNC_QUALIFIER bool operator!=(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2) { return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]); diff --git a/glm/detail/type_vec.hpp b/glm/detail/type_vec.hpp index 2e90cd55..2a5be39a 100644 --- a/glm/detail/type_vec.hpp +++ b/glm/detail/type_vec.hpp @@ -3,7 +3,7 @@ #pragma once -#include "precision.hpp" +#include "qualifier.hpp" #include "type_int.hpp" #include "compute_vector_relational.hpp" @@ -103,10 +103,10 @@ namespace detail }//namespace detail #if GLM_HAS_TEMPLATE_ALIASES - template using tvec1 = vec<1, T, P>; - template using tvec2 = vec<2, T, P>; - template using tvec3 = vec<3, T, P>; - template using tvec4 = vec<4, T, P>; + template using tvec1 = vec<1, T, P>; + template using tvec2 = vec<2, T, P>; + template using tvec3 = vec<3, T, P>; + template using tvec4 = vec<4, T, P>; #endif//GLM_HAS_TEMPLATE_ALIASES typedef vec<1, float, highp> highp_vec1_t; @@ -128,106 +128,106 @@ namespace detail /// @addtogroup core_precision /// @{ - /// 2 components vector of high single-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of high single-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, float, highp> highp_vec2; - /// 2 components vector of medium single-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of medium single-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, float, mediump> mediump_vec2; - /// 2 components vector of low single-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of low single-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, float, lowp> lowp_vec2; - /// 2 components vector of high double-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of high double-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, double, highp> highp_dvec2; - /// 2 components vector of medium double-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of medium double-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, double, mediump> mediump_dvec2; - /// 2 components vector of low double-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of low double-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, double, lowp> lowp_dvec2; - /// 2 components vector of high precision signed integer numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of high qualifier signed integer numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, int, highp> highp_ivec2; - /// 2 components vector of medium precision signed integer numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of medium qualifier signed integer numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, int, mediump> mediump_ivec2; - /// 2 components vector of low precision signed integer numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of low qualifier signed integer numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, int, lowp> lowp_ivec2; - /// 2 components vector of high precision unsigned integer numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of high qualifier unsigned integer numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, uint, highp> highp_uvec2; - /// 2 components vector of medium precision unsigned integer numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of medium qualifier unsigned integer numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, uint, mediump> mediump_uvec2; - /// 2 components vector of low precision unsigned integer numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of low qualifier unsigned integer numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, uint, lowp> lowp_uvec2; - /// 2 components vector of high precision bool numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of high qualifier bool numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, bool, highp> highp_bvec2; - /// 2 components vector of medium precision bool numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of medium qualifier bool numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<2, bool, mediump> mediump_bvec2; - /// 2 components vector of low precision bool numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of low qualifier bool numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier @@ -238,103 +238,103 @@ namespace detail /// @addtogroup core_precision /// @{ - /// 3 components vector of high single-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of high single-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, float, highp> highp_vec3; - /// 3 components vector of medium single-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of medium single-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, float, mediump> mediump_vec3; - /// 3 components vector of low single-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of low single-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, float, lowp> lowp_vec3; - /// 3 components vector of high double-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of high double-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, double, highp> highp_dvec3; - /// 3 components vector of medium double-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of medium double-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, double, mediump> mediump_dvec3; - /// 3 components vector of low double-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of low double-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, double, lowp> lowp_dvec3; - /// 3 components vector of high precision signed integer numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of high qualifier signed integer numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, int, highp> highp_ivec3; - /// 3 components vector of medium precision signed integer numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of medium qualifier signed integer numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, int, mediump> mediump_ivec3; - /// 3 components vector of low precision signed integer numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of low qualifier signed integer numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, int, lowp> lowp_ivec3; - /// 3 components vector of high precision unsigned integer numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of high qualifier unsigned integer numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, uint, highp> highp_uvec3; - /// 3 components vector of medium precision unsigned integer numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of medium qualifier unsigned integer numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, uint, mediump> mediump_uvec3; - /// 3 components vector of low precision unsigned integer numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of low qualifier unsigned integer numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, uint, lowp> lowp_uvec3; - /// 3 components vector of high precision bool numbers. + /// 3 components vector of high qualifier bool numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, bool, highp> highp_bvec3; - /// 3 components vector of medium precision bool numbers. + /// 3 components vector of medium qualifier bool numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<3, bool, mediump> mediump_bvec3; - /// 3 components vector of low precision bool numbers. + /// 3 components vector of low qualifier bool numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier @@ -345,91 +345,91 @@ namespace detail /// @addtogroup core_precision /// @{ - /// 4 components vector of high single-precision floating-point numbers. + /// 4 components vector of high single-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, float, highp> highp_vec4; - /// 4 components vector of medium single-precision floating-point numbers. + /// 4 components vector of medium single-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, float, mediump> mediump_vec4; - /// 4 components vector of low single-precision floating-point numbers. + /// 4 components vector of low single-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, float, lowp> lowp_vec4; - /// 4 components vector of high double-precision floating-point numbers. + /// 4 components vector of high double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, double, highp> highp_dvec4; - /// 4 components vector of medium double-precision floating-point numbers. + /// 4 components vector of medium double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, double, mediump> mediump_dvec4; - /// 4 components vector of low double-precision floating-point numbers. + /// 4 components vector of low double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, double, lowp> lowp_dvec4; - /// 4 components vector of high precision signed integer numbers. + /// 4 components vector of high qualifier signed integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, int, highp> highp_ivec4; - /// 4 components vector of medium precision signed integer numbers. + /// 4 components vector of medium qualifier signed integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, int, mediump> mediump_ivec4; - /// 4 components vector of low precision signed integer numbers. + /// 4 components vector of low qualifier signed integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, int, lowp> lowp_ivec4; - /// 4 components vector of high precision unsigned integer numbers. + /// 4 components vector of high qualifier unsigned integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, uint, highp> highp_uvec4; - /// 4 components vector of medium precision unsigned integer numbers. + /// 4 components vector of medium qualifier unsigned integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, uint, mediump> mediump_uvec4; - /// 4 components vector of low precision unsigned integer numbers. + /// 4 components vector of low qualifier unsigned integer numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, uint, lowp> lowp_uvec4; - /// 4 components vector of high precision bool numbers. + /// 4 components vector of high qualifier bool numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, bool, highp> highp_bvec4; - /// 4 components vector of medium precision bool numbers. + /// 4 components vector of medium qualifier bool numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef vec<4, bool, mediump> mediump_bvec4; - /// 4 components vector of low precision bool numbers. + /// 4 components vector of low qualifier bool numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier @@ -478,17 +478,17 @@ namespace detail typedef mediump_dvec3 dvec3; typedef mediump_dvec4 dvec4; #else //defined(GLM_PRECISION_HIGHP_DOUBLE) - /// 2 components vector of double-precision floating-point numbers. + /// 2 components vector of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef highp_dvec2 dvec2; - //! 3 components vector of double-precision floating-point numbers. + //! 3 components vector of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef highp_dvec3 dvec3; - //! 4 components vector of double-precision floating-point numbers. + //! 4 components vector of double-qualifier floating-point numbers. /// /// @see GLSL 4.20.8 specification, section 4.1.5 Vectors typedef highp_dvec4 dvec4; diff --git a/glm/detail/type_vec1.hpp b/glm/detail/type_vec1.hpp index 1500631b..328264b3 100644 --- a/glm/detail/type_vec1.hpp +++ b/glm/detail/type_vec1.hpp @@ -16,7 +16,7 @@ namespace glm { - template + template struct vec<1, T, P> { // -- Implementation detail -- @@ -87,7 +87,7 @@ namespace glm GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec() GLM_DEFAULT; GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec const& v) GLM_DEFAULT; - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<1, T, Q> const& v); // -- Explicit basic constructors -- @@ -97,17 +97,17 @@ namespace glm // -- Conversion vector constructors -- /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<2, U, Q> const& v); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<3, U, Q> const& v); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<4, U, Q> const& v); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<1, U, Q> const& v); // -- Swizzle constructors -- @@ -180,119 +180,119 @@ namespace glm // -- Unary operators -- - template + template GLM_FUNC_DECL vec<1, T, P> operator+(vec<1, T, P> const& v); - template + template GLM_FUNC_DECL vec<1, T, P> operator-(vec<1, T, P> const& v); // -- Binary operators -- - template + template GLM_FUNC_DECL vec<1, T, P> operator+(vec<1, T, P> const& v, T scalar); - template + template GLM_FUNC_DECL vec<1, T, P> operator+(T scalar, vec<1, T, P> const& v); - template + template GLM_FUNC_DECL vec<1, T, P> operator+(vec<1, T, P> const& v1, vec<1, T, P> const& v2); - template + template GLM_FUNC_DECL vec<1, T, P> operator-(vec<1, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<1, T, P> operator-(T scalar, vec<1, T, P> const& v); - template + template GLM_FUNC_DECL vec<1, T, P> operator-(vec<1, T, P> const& v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<1, T, P> operator*(vec<1, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<1, T, P> operator*(T scalar, vec<1, T, P> const & v); - template + template GLM_FUNC_DECL vec<1, T, P> operator*(vec<1, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<1, T, P> operator/(vec<1, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<1, T, P> operator/(T scalar, vec<1, T, P> const & v); - template + template GLM_FUNC_DECL vec<1, T, P> operator/(vec<1, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<1, T, P> operator%(vec<1, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<1, T, P> operator%(T scalar, vec<1, T, P> const & v); - template + template GLM_FUNC_DECL vec<1, T, P> operator%(vec<1, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<1, T, P> operator&(vec<1, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<1, T, P> operator&(T scalar, vec<1, T, P> const & v); - template + template GLM_FUNC_DECL vec<1, T, P> operator&(vec<1, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<1, T, P> operator|(vec<1, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<1, T, P> operator|(T scalar, vec<1, T, P> const & v); - template + template GLM_FUNC_DECL vec<1, T, P> operator|(vec<1, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<1, T, P> operator^(vec<1, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<1, T, P> operator^(T scalar, vec<1, T, P> const & v); - template + template GLM_FUNC_DECL vec<1, T, P> operator^(vec<1, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<1, T, P> operator<<(vec<1, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<1, T, P> operator<<(T scalar, vec<1, T, P> const & v); - template + template GLM_FUNC_DECL vec<1, T, P> operator<<(vec<1, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<1, T, P> operator>>(vec<1, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<1, T, P> operator>>(T scalar, vec<1, T, P> const & v); - template + template GLM_FUNC_DECL vec<1, T, P> operator>>(vec<1, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<1, T, P> operator~(vec<1, T, P> const & v); // -- Boolean operators -- - template + template GLM_FUNC_DECL bool operator==(vec<1, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL bool operator!=(vec<1, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<1, bool, P> operator&&(vec<1, bool, P> const & v1, vec<1, bool, P> const & v2); - template + template GLM_FUNC_DECL vec<1, bool, P> operator||(vec<1, bool, P> const & v1, vec<1, bool, P> const & v2); }//namespace glm diff --git a/glm/detail/type_vec1.inl b/glm/detail/type_vec1.inl index 6bce5d42..84a5e674 100644 --- a/glm/detail/type_vec1.inl +++ b/glm/detail/type_vec1.inl @@ -6,67 +6,67 @@ namespace glm // -- Implicit basic constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, P>::vec() {} # endif//!GLM_HAS_DEFAULTED_FUNCTIONS # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, P>::vec(vec<1, T, P> const & v) : x(v.x) {} # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, P>::vec(vec<1, T, Q> const& v) : x(v.x) {} // -- Explicit basic constructors -- - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, P>::vec(T scalar) : x(scalar) {} // -- Conversion vector constructors -- - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, P>::vec(vec<1, U, Q> const & v) : x(static_cast(v.x)) {} - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, P>::vec(vec<2, U, Q> const & v) : x(static_cast(v.x)) {} - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, P>::vec(vec<3, U, Q> const & v) : x(static_cast(v.x)) {} - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, P>::vec(vec<4, U, Q> const & v) : x(static_cast(v.x)) {} // -- Component accesses -- - template + template GLM_FUNC_QUALIFIER T & vec<1, T, P>::operator[](typename vec<1, T, P>::length_type i) { assert(i >= 0 && i < this->length()); return (&x)[i]; } - template + template GLM_FUNC_QUALIFIER T const & vec<1, T, P>::operator[](typename vec<1, T, P>::length_type i) const { assert(i >= 0 && i < this->length()); @@ -76,7 +76,7 @@ namespace glm // -- Unary arithmetic operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator=(vec<1, T, P> const & v) { this->x = v.x; @@ -84,7 +84,7 @@ namespace glm } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template + template template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator=(vec<1, U, P> const & v) { @@ -92,7 +92,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator+=(U scalar) { @@ -100,7 +100,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator+=(vec<1, U, P> const & v) { @@ -108,7 +108,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator-=(U scalar) { @@ -116,7 +116,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator-=(vec<1, U, P> const & v) { @@ -124,7 +124,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator*=(U scalar) { @@ -132,7 +132,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator*=(vec<1, U, P> const & v) { @@ -140,7 +140,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator/=(U scalar) { @@ -148,7 +148,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator/=(vec<1, U, P> const & v) { @@ -158,21 +158,21 @@ namespace glm // -- Increment and decrement operators -- - template + template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator++() { ++this->x; return *this; } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator--() { --this->x; return *this; } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> vec<1, T, P>::operator++(int) { vec<1, T, P> Result(*this); @@ -180,7 +180,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> vec<1, T, P>::operator--(int) { vec<1, T, P> Result(*this); @@ -190,7 +190,7 @@ namespace glm // -- Unary bit operators -- - template + template template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator%=(U scalar) { @@ -198,7 +198,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator%=(vec<1, U, P> const & v) { @@ -206,7 +206,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator&=(U scalar) { @@ -214,7 +214,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator&=(vec<1, U, P> const & v) { @@ -222,7 +222,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator|=(U scalar) { @@ -230,7 +230,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator|=(vec<1, U, P> const & v) { @@ -238,7 +238,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator^=(U scalar) { @@ -246,7 +246,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator^=(vec<1, U, P> const & v) { @@ -254,7 +254,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator<<=(U scalar) { @@ -262,7 +262,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator<<=(vec<1, U, P> const & v) { @@ -270,7 +270,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator>>=(U scalar) { @@ -278,7 +278,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator>>=(vec<1, U, P> const & v) { @@ -288,13 +288,13 @@ namespace glm // -- Unary constant operators -- - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator+(vec<1, T, P> const & v) { return v; } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator-(vec<1, T, P> const & v) { return vec<1, T, P>( @@ -303,21 +303,21 @@ namespace glm // -- Binary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator+(vec<1, T, P> const & v, T scalar) { return vec<1, T, P>( v.x + scalar); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator+(T scalar, vec<1, T, P> const & v) { return vec<1, T, P>( scalar + v.x); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator+(vec<1, T, P> const & v1, vec<1, T, P> const & v2) { return vec<1, T, P>( @@ -325,63 +325,63 @@ namespace glm } //operator- - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator-(vec<1, T, P> const & v, T scalar) { return vec<1, T, P>( v.x - scalar); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator-(T scalar, vec<1, T, P> const & v) { return vec<1, T, P>( scalar - v.x); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator-(vec<1, T, P> const & v1, vec<1, T, P> const & v2) { return vec<1, T, P>( v1.x - v2.x); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator*(vec<1, T, P> const & v, T scalar) { return vec<1, T, P>( v.x * scalar); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator*(T scalar, vec<1, T, P> const & v) { return vec<1, T, P>( scalar * v.x); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator*(vec<1, T, P> const & v1, vec<1, T, P> const & v2) { return vec<1, T, P>( v1.x * v2.x); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator/(vec<1, T, P> const & v, T scalar) { return vec<1, T, P>( v.x / scalar); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator/(T scalar, vec<1, T, P> const & v) { return vec<1, T, P>( scalar / v.x); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator/(vec<1, T, P> const & v1, vec<1, T, P> const & v2) { return vec<1, T, P>( @@ -390,133 +390,133 @@ namespace glm // -- Binary bit operators -- - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator%(vec<1, T, P> const & v, T scalar) { return vec<1, T, P>( v.x % scalar); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator%(T scalar, vec<1, T, P> const & v) { return vec<1, T, P>( scalar % v.x); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator%(vec<1, T, P> const & v1, vec<1, T, P> const & v2) { return vec<1, T, P>( v1.x % v2.x); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator&(vec<1, T, P> const & v, T scalar) { return vec<1, T, P>( v.x & scalar); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator&(T scalar, vec<1, T, P> const & v) { return vec<1, T, P>( scalar & v.x); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator&(vec<1, T, P> const & v1, vec<1, T, P> const & v2) { return vec<1, T, P>( v1.x & v2.x); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator|(vec<1, T, P> const & v, T scalar) { return vec<1, T, P>( v.x | scalar); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator|(T scalar, vec<1, T, P> const & v) { return vec<1, T, P>( scalar | v.x); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator|(vec<1, T, P> const & v1, vec<1, T, P> const & v2) { return vec<1, T, P>( v1.x | v2.x); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator^(vec<1, T, P> const & v, T scalar) { return vec<1, T, P>( v.x ^ scalar); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator^(T scalar, vec<1, T, P> const & v) { return vec<1, T, P>( scalar ^ v.x); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator^(vec<1, T, P> const & v1, vec<1, T, P> const & v2) { return vec<1, T, P>( v1.x ^ v2.x); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator<<(vec<1, T, P> const & v, T scalar) { return vec<1, T, P>( static_cast(v.x << scalar)); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator<<(T scalar, vec<1, T, P> const & v) { return vec<1, T, P>( scalar << v.x); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator<<(vec<1, T, P> const & v1, vec<1, T, P> const & v2) { return vec<1, T, P>( v1.x << v2.x); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator>>(vec<1, T, P> const & v, T scalar) { return vec<1, T, P>( v.x >> scalar); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator>>(T scalar, vec<1, T, P> const & v) { return vec<1, T, P>( scalar >> v.x); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator>>(vec<1, T, P> const & v1, vec<1, T, P> const & v2) { return vec<1, T, P>( v1.x >> v2.x); } - template + template GLM_FUNC_QUALIFIER vec<1, T, P> operator~(vec<1, T, P> const & v) { return vec<1, T, P>( @@ -525,25 +525,25 @@ namespace glm // -- Boolean operators -- - template + template GLM_FUNC_QUALIFIER bool operator==(vec<1, T, P> const & v1, vec<1, T, P> const & v2) { return detail::compute_equal::call(v1.x, v2.x); } - template + template GLM_FUNC_QUALIFIER bool operator!=(vec<1, T, P> const & v1, vec<1, T, P> const & v2) { return !(v1 == v2); } - template + template GLM_FUNC_QUALIFIER vec<1, bool, P> operator&&(vec<1, bool, P> const & v1, vec<1, bool, P> const & v2) { return vec<1, bool, P>(v1.x && v2.x); } - template + template GLM_FUNC_QUALIFIER vec<1, bool, P> operator||(vec<1, bool, P> const & v1, vec<1, bool, P> const & v2) { return vec<1, bool, P>(v1.x || v2.x); diff --git a/glm/detail/type_vec2.hpp b/glm/detail/type_vec2.hpp index 55bd8214..fa6597d1 100644 --- a/glm/detail/type_vec2.hpp +++ b/glm/detail/type_vec2.hpp @@ -15,7 +15,7 @@ namespace glm { - template + template struct vec<2, T, P> { // -- Implementation detail -- @@ -88,7 +88,7 @@ namespace glm GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec() GLM_DEFAULT; GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec const& v) GLM_DEFAULT; - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<2, T, Q> const& v); // -- Explicit basic constructors -- @@ -107,14 +107,14 @@ namespace glm // -- Conversion vector constructors -- /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<3, U, Q> const& v); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<4, U, Q> const& v); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<2, U, Q> const& v); // -- Swizzle constructors -- @@ -206,179 +206,179 @@ namespace glm // -- Unary operators -- - template + template GLM_FUNC_DECL vec<2, T, P> operator+(vec<2, T, P> const & v); - template + template GLM_FUNC_DECL vec<2, T, P> operator-(vec<2, T, P> const & v); // -- Binary operators -- - template + template GLM_FUNC_DECL vec<2, T, P> operator+(vec<2, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<2, T, P> operator+(vec<2, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator+(T scalar, vec<2, T, P> const & v); - template + template GLM_FUNC_DECL vec<2, T, P> operator+(vec<1, T, P> const & v1, vec<2, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator+(vec<2, T, P> const & v1, vec<2, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator-(vec<2, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<2, T, P> operator-(vec<2, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator-(T scalar, vec<2, T, P> const & v); - template + template GLM_FUNC_DECL vec<2, T, P> operator-(vec<1, T, P> const & v1, vec<2, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator-(vec<2, T, P> const & v1, vec<2, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator*(vec<2, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<2, T, P> operator*(vec<2, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator*(T scalar, vec<2, T, P> const & v); - template + template GLM_FUNC_DECL vec<2, T, P> operator*(vec<1, T, P> const & v1, vec<2, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator*(vec<2, T, P> const & v1, vec<2, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator/(vec<2, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<2, T, P> operator/(vec<2, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator/(T scalar, vec<2, T, P> const & v); - template + template GLM_FUNC_DECL vec<2, T, P> operator/(vec<1, T, P> const & v1, vec<2, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator/(vec<2, T, P> const & v1, vec<2, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator%(vec<2, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<2, T, P> operator%(vec<2, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator%(T scalar, vec<2, T, P> const & v); - template + template GLM_FUNC_DECL vec<2, T, P> operator%(vec<1, T, P> const & v1, vec<2, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator%(vec<2, T, P> const & v1, vec<2, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator&(vec<2, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<2, T, P> operator&(vec<2, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator&(T scalar, vec<2, T, P> const & v); - template + template GLM_FUNC_DECL vec<2, T, P> operator&(vec<1, T, P> const & v1, vec<2, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator&(vec<2, T, P> const & v1, vec<2, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator|(vec<2, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<2, T, P> operator|(vec<2, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator|(T scalar, vec<2, T, P> const & v); - template + template GLM_FUNC_DECL vec<2, T, P> operator|(vec<1, T, P> const & v1, vec<2, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator|(vec<2, T, P> const & v1, vec<2, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator^(vec<2, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<2, T, P> operator^(vec<2, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator^(T scalar, vec<2, T, P> const & v); - template + template GLM_FUNC_DECL vec<2, T, P> operator^(vec<1, T, P> const & v1, vec<2, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator^(vec<2, T, P> const & v1, vec<2, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator<<(vec<2, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<2, T, P> operator<<(vec<2, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator<<(T scalar, vec<2, T, P> const & v); - template + template GLM_FUNC_DECL vec<2, T, P> operator<<(vec<1, T, P> const & v1, vec<2, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator<<(vec<2, T, P> const & v1, vec<2, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator>>(vec<2, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<2, T, P> operator>>(vec<2, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator>>(T scalar, vec<2, T, P> const & v); - template + template GLM_FUNC_DECL vec<2, T, P> operator>>(vec<1, T, P> const & v1, vec<2, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator>>(vec<2, T, P> const & v1, vec<2, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, T, P> operator~(vec<2, T, P> const & v); // -- Boolean operators -- - template + template GLM_FUNC_DECL bool operator==(vec<2, T, P> const & v1, vec<2, T, P> const & v2); - template + template GLM_FUNC_DECL bool operator!=(vec<2, T, P> const & v1, vec<2, T, P> const & v2); - template + template GLM_FUNC_DECL vec<2, bool, P> operator&&(vec<2, bool, P> const & v1, vec<2, bool, P> const & v2); - template + template GLM_FUNC_DECL vec<2, bool, P> operator||(vec<2, bool, P> const & v1, vec<2, bool, P> const & v2); }//namespace glm diff --git a/glm/detail/type_vec2.inl b/glm/detail/type_vec2.inl index 7b950042..cd31d564 100644 --- a/glm/detail/type_vec2.inl +++ b/glm/detail/type_vec2.inl @@ -6,46 +6,46 @@ namespace glm // -- Implicit basic constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, P>::vec() {} # endif//!GLM_HAS_DEFAULTED_FUNCTIONS # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, P>::vec(vec<2, T, P> const& v) : x(v.x), y(v.y) {} # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, P>::vec(vec<2, T, Q> const& v) : x(v.x), y(v.y) {} // -- Explicit basic constructors -- - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, P>::vec(T scalar) : x(scalar), y(scalar) {} - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, P>::vec(T _x, T _y) : x(_x), y(_y) {} // -- Conversion scalar constructors -- - template + template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, P>::vec(A _x, B _y) : x(static_cast(_x)) , y(static_cast(_y)) {} - template + template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, P>::vec(vec<1, A, P> const& _x, vec<1, B, P> const& _y) : x(static_cast(_x.x)) @@ -54,22 +54,22 @@ namespace glm // -- Conversion vector constructors -- - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, P>::vec(vec<2, U, Q> const& v) : x(static_cast(v.x)) , y(static_cast(v.y)) {} - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, P>::vec(vec<3, U, Q> const& v) : x(static_cast(v.x)) , y(static_cast(v.y)) {} - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, P>::vec(vec<4, U, Q> const& v) : x(static_cast(v.x)) , y(static_cast(v.y)) @@ -77,14 +77,14 @@ namespace glm // -- Component accesses -- - template + template GLM_FUNC_QUALIFIER T & vec<2, T, P>::operator[](typename vec<2, T, P>::length_type i) { assert(i >= 0 && i < this->length()); return (&x)[i]; } - template + template GLM_FUNC_QUALIFIER T const & vec<2, T, P>::operator[](typename vec<2, T, P>::length_type i) const { assert(i >= 0 && i < this->length()); @@ -94,7 +94,7 @@ namespace glm // -- Unary arithmetic operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator=(vec<2, T, P> const& v) { this->x = v.x; @@ -103,7 +103,7 @@ namespace glm } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator=(vec<2, U, P> const& v) { @@ -112,7 +112,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator+=(U scalar) { @@ -121,7 +121,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator+=(vec<1, U, P> const& v) { @@ -130,7 +130,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator+=(vec<2, U, P> const& v) { @@ -139,7 +139,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator-=(U scalar) { @@ -148,7 +148,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator-=(vec<1, U, P> const& v) { @@ -157,7 +157,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator-=(vec<2, U, P> const& v) { @@ -166,7 +166,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator*=(U scalar) { @@ -175,7 +175,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator*=(vec<1, U, P> const& v) { @@ -184,7 +184,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator*=(vec<2, U, P> const& v) { @@ -193,7 +193,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator/=(U scalar) { @@ -202,7 +202,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator/=(vec<1, U, P> const& v) { @@ -211,7 +211,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator/=(vec<2, U, P> const& v) { @@ -222,7 +222,7 @@ namespace glm // -- Increment and decrement operators -- - template + template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator++() { ++this->x; @@ -230,7 +230,7 @@ namespace glm return *this; } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator--() { --this->x; @@ -238,7 +238,7 @@ namespace glm return *this; } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> vec<2, T, P>::operator++(int) { vec<2, T, P> Result(*this); @@ -246,7 +246,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> vec<2, T, P>::operator--(int) { vec<2, T, P> Result(*this); @@ -256,7 +256,7 @@ namespace glm // -- Unary bit operators -- - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator%=(U scalar) { @@ -265,7 +265,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator%=(vec<1, U, P> const& v) { @@ -274,7 +274,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator%=(vec<2, U, P> const& v) { @@ -283,7 +283,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator&=(U scalar) { @@ -292,7 +292,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator&=(vec<1, U, P> const& v) { @@ -301,7 +301,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator&=(vec<2, U, P> const& v) { @@ -310,7 +310,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator|=(U scalar) { @@ -319,7 +319,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator|=(vec<1, U, P> const& v) { @@ -328,7 +328,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator|=(vec<2, U, P> const& v) { @@ -337,7 +337,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator^=(U scalar) { @@ -346,7 +346,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator^=(vec<1, U, P> const& v) { @@ -355,7 +355,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator^=(vec<2, U, P> const& v) { @@ -364,7 +364,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator<<=(U scalar) { @@ -373,7 +373,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator<<=(vec<1, U, P> const& v) { @@ -382,7 +382,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator<<=(vec<2, U, P> const& v) { @@ -391,7 +391,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator>>=(U scalar) { @@ -400,7 +400,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator>>=(vec<1, U, P> const& v) { @@ -409,7 +409,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator>>=(vec<2, U, P> const& v) { @@ -420,13 +420,13 @@ namespace glm // -- Unary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator+(vec<2, T, P> const& v) { return v; } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator-(vec<2, T, P> const& v) { return vec<2, T, P>( @@ -436,7 +436,7 @@ namespace glm // -- Binary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator+(vec<2, T, P> const& v, T scalar) { return vec<2, T, P>( @@ -444,7 +444,7 @@ namespace glm v.y + scalar); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator+(vec<2, T, P> const& v1, vec<1, T, P> const& v2) { return vec<2, T, P>( @@ -452,7 +452,7 @@ namespace glm v1.y + v2.x); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator+(T scalar, vec<2, T, P> const& v) { return vec<2, T, P>( @@ -460,7 +460,7 @@ namespace glm scalar + v.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator+(vec<1, T, P> const& v1, vec<2, T, P> const& v2) { return vec<2, T, P>( @@ -468,7 +468,7 @@ namespace glm v1.x + v2.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator+(vec<2, T, P> const & v1, vec<2, T, P> const & v2) { return vec<2, T, P>( @@ -476,7 +476,7 @@ namespace glm v1.y + v2.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator-(vec<2, T, P> const & v, T scalar) { return vec<2, T, P>( @@ -484,7 +484,7 @@ namespace glm v.y - scalar); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator-(vec<2, T, P> const & v1, vec<1, T, P> const & v2) { return vec<2, T, P>( @@ -492,7 +492,7 @@ namespace glm v1.y - v2.x); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator-(T scalar, vec<2, T, P> const & v) { return vec<2, T, P>( @@ -500,7 +500,7 @@ namespace glm scalar - v.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator-(vec<1, T, P> const & v1, vec<2, T, P> const & v2) { return vec<2, T, P>( @@ -508,7 +508,7 @@ namespace glm v1.x - v2.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator-(vec<2, T, P> const & v1, vec<2, T, P> const & v2) { return vec<2, T, P>( @@ -516,7 +516,7 @@ namespace glm v1.y - v2.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator*(vec<2, T, P> const & v, T scalar) { return vec<2, T, P>( @@ -524,7 +524,7 @@ namespace glm v.y * scalar); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator*(vec<2, T, P> const & v1, vec<1, T, P> const & v2) { return vec<2, T, P>( @@ -532,7 +532,7 @@ namespace glm v1.y * v2.x); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator*(T scalar, vec<2, T, P> const & v) { return vec<2, T, P>( @@ -540,7 +540,7 @@ namespace glm scalar * v.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator*(vec<1, T, P> const & v1, vec<2, T, P> const & v2) { return vec<2, T, P>( @@ -548,7 +548,7 @@ namespace glm v1.x * v2.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator*(vec<2, T, P> const & v1, vec<2, T, P> const & v2) { return vec<2, T, P>( @@ -556,7 +556,7 @@ namespace glm v1.y * v2.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator/(vec<2, T, P> const & v, T scalar) { return vec<2, T, P>( @@ -564,7 +564,7 @@ namespace glm v.y / scalar); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator/(vec<2, T, P> const & v1, vec<1, T, P> const & v2) { return vec<2, T, P>( @@ -572,7 +572,7 @@ namespace glm v1.y / v2.x); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator/(T scalar, vec<2, T, P> const & v) { return vec<2, T, P>( @@ -580,7 +580,7 @@ namespace glm scalar / v.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator/(vec<1, T, P> const & v1, vec<2, T, P> const & v2) { return vec<2, T, P>( @@ -588,7 +588,7 @@ namespace glm v1.x / v2.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator/(vec<2, T, P> const & v1, vec<2, T, P> const & v2) { return vec<2, T, P>( @@ -598,7 +598,7 @@ namespace glm // -- Binary bit operators -- - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator%(vec<2, T, P> const & v, T scalar) { return vec<2, T, P>( @@ -606,7 +606,7 @@ namespace glm v.y % scalar); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator%(vec<2, T, P> const & v1, vec<1, T, P> const & v2) { return vec<2, T, P>( @@ -614,7 +614,7 @@ namespace glm v1.y % v2.x); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator%(T scalar, vec<2, T, P> const & v) { return vec<2, T, P>( @@ -622,7 +622,7 @@ namespace glm scalar % v.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator%(vec<1, T, P> const & v1, vec<2, T, P> const & v2) { return vec<2, T, P>( @@ -630,7 +630,7 @@ namespace glm v1.x % v2.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator%(vec<2, T, P> const & v1, vec<2, T, P> const & v2) { return vec<2, T, P>( @@ -638,7 +638,7 @@ namespace glm v1.y % v2.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator&(vec<2, T, P> const & v, T scalar) { return vec<2, T, P>( @@ -646,7 +646,7 @@ namespace glm v.y & scalar); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator&(vec<2, T, P> const & v1, vec<1, T, P> const & v2) { return vec<2, T, P>( @@ -654,7 +654,7 @@ namespace glm v1.y & v2.x); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator&(T scalar, vec<2, T, P> const & v) { return vec<2, T, P>( @@ -662,7 +662,7 @@ namespace glm scalar & v.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator&(vec<1, T, P> const & v1, vec<2, T, P> const & v2) { return vec<2, T, P>( @@ -670,7 +670,7 @@ namespace glm v1.x & v2.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator&(vec<2, T, P> const & v1, vec<2, T, P> const & v2) { return vec<2, T, P>( @@ -678,7 +678,7 @@ namespace glm v1.y & v2.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator|(vec<2, T, P> const & v, T scalar) { return vec<2, T, P>( @@ -686,7 +686,7 @@ namespace glm v.y | scalar); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator|(vec<2, T, P> const & v1, vec<1, T, P> const & v2) { return vec<2, T, P>( @@ -694,7 +694,7 @@ namespace glm v1.y | v2.x); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator|(T scalar, vec<2, T, P> const & v) { return vec<2, T, P>( @@ -702,7 +702,7 @@ namespace glm scalar | v.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator|(vec<1, T, P> const & v1, vec<2, T, P> const & v2) { return vec<2, T, P>( @@ -710,7 +710,7 @@ namespace glm v1.x | v2.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator|(vec<2, T, P> const & v1, vec<2, T, P> const & v2) { return vec<2, T, P>( @@ -718,7 +718,7 @@ namespace glm v1.y | v2.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator^(vec<2, T, P> const & v, T scalar) { return vec<2, T, P>( @@ -726,7 +726,7 @@ namespace glm v.y ^ scalar); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator^(vec<2, T, P> const & v1, vec<1, T, P> const & v2) { return vec<2, T, P>( @@ -734,7 +734,7 @@ namespace glm v1.y ^ v2.x); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator^(T scalar, vec<2, T, P> const & v) { return vec<2, T, P>( @@ -742,7 +742,7 @@ namespace glm scalar ^ v.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator^(vec<1, T, P> const & v1, vec<2, T, P> const & v2) { return vec<2, T, P>( @@ -750,7 +750,7 @@ namespace glm v1.x ^ v2.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator^(vec<2, T, P> const & v1, vec<2, T, P> const & v2) { return vec<2, T, P>( @@ -758,7 +758,7 @@ namespace glm v1.y ^ v2.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator<<(vec<2, T, P> const & v, T scalar) { return vec<2, T, P>( @@ -766,7 +766,7 @@ namespace glm v.y << scalar); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator<<(vec<2, T, P> const & v1, vec<1, T, P> const & v2) { return vec<2, T, P>( @@ -774,7 +774,7 @@ namespace glm v1.y << v2.x); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator<<(T scalar, vec<2, T, P> const & v) { return vec<2, T, P>( @@ -782,7 +782,7 @@ namespace glm scalar << v.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator<<(vec<1, T, P> const & v1, vec<2, T, P> const & v2) { return vec<2, T, P>( @@ -790,7 +790,7 @@ namespace glm v1.x << v2.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator<<(vec<2, T, P> const & v1, vec<2, T, P> const & v2) { return vec<2, T, P>( @@ -798,7 +798,7 @@ namespace glm v1.y << v2.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator>>(vec<2, T, P> const & v, T scalar) { return vec<2, T, P>( @@ -806,7 +806,7 @@ namespace glm v.y >> scalar); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator>>(vec<2, T, P> const & v1, vec<1, T, P> const & v2) { return vec<2, T, P>( @@ -814,7 +814,7 @@ namespace glm v1.y >> v2.x); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator>>(T scalar, vec<2, T, P> const & v) { return vec<2, T, P>( @@ -822,7 +822,7 @@ namespace glm scalar >> v.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator>>(vec<1, T, P> const & v1, vec<2, T, P> const & v2) { return vec<2, T, P>( @@ -830,7 +830,7 @@ namespace glm v1.x >> v2.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator>>(vec<2, T, P> const & v1, vec<2, T, P> const & v2) { return vec<2, T, P>( @@ -838,7 +838,7 @@ namespace glm v1.y >> v2.y); } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> operator~(vec<2, T, P> const & v) { return vec<2, T, P>( @@ -848,7 +848,7 @@ namespace glm // -- Boolean operators -- - template + template GLM_FUNC_QUALIFIER bool operator==(vec<2, T, P> const & v1, vec<2, T, P> const & v2) { return @@ -856,19 +856,19 @@ namespace glm detail::compute_equal::call(v1.y, v2.y); } - template + template GLM_FUNC_QUALIFIER bool operator!=(vec<2, T, P> const & v1, vec<2, T, P> const & v2) { return !(v1 == v2); } - template + template GLM_FUNC_QUALIFIER vec<2, bool, P> operator&&(vec<2, bool, P> const & v1, vec<2, bool, P> const & v2) { return vec<2, bool, P>(v1.x && v2.x, v1.y && v2.y); } - template + template GLM_FUNC_QUALIFIER vec<2, bool, P> operator||(vec<2, bool, P> const & v1, vec<2, bool, P> const & v2) { return vec<2, bool, P>(v1.x || v2.x, v1.y || v2.y); diff --git a/glm/detail/type_vec3.hpp b/glm/detail/type_vec3.hpp index 24dc7da0..5d1e1d8d 100644 --- a/glm/detail/type_vec3.hpp +++ b/glm/detail/type_vec3.hpp @@ -15,7 +15,7 @@ namespace glm { - template + template struct vec<3, T, P> { // -- Implementation detail -- @@ -88,7 +88,7 @@ namespace glm GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec() GLM_DEFAULT; GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec const & v) GLM_DEFAULT; - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<3, T, Q> const & v); // -- Explicit basic constructors -- @@ -107,23 +107,23 @@ namespace glm // -- Conversion vector constructors -- /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<2, A, Q> const& _xy, B _z); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<2, A, Q> const& _xy, vec<1, B, Q> const& _z); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(A _x, vec<2, B, Q> const& _yz); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<1, A, Q> const& _x, vec<2, B, Q> const& _yz); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<4, U, Q> const& v); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<3, U, Q> const& v); // -- Swizzle constructors -- @@ -227,179 +227,179 @@ namespace glm // -- Unary operators -- - template + template GLM_FUNC_DECL vec<3, T, P> operator+(vec<3, T, P> const & v); - template + template GLM_FUNC_DECL vec<3, T, P> operator-(vec<3, T, P> const & v); // -- Binary operators -- - template + template GLM_FUNC_DECL vec<3, T, P> operator+(vec<3, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<3, T, P> operator+(vec<3, T, P> const & v, vec<1, T, P> const & scalar); - template + template GLM_FUNC_DECL vec<3, T, P> operator+(T scalar, vec<3, T, P> const & v); - template + template GLM_FUNC_DECL vec<3, T, P> operator+(vec<1, T, P> const & v1, vec<3, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator+(vec<3, T, P> const & v1, vec<3, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator-(vec<3, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<3, T, P> operator-(vec<3, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator-(T scalar, vec<3, T, P> const & v); - template + template GLM_FUNC_DECL vec<3, T, P> operator-(vec<1, T, P> const & v1, vec<3, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator-(vec<3, T, P> const & v1, vec<3, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator*(vec<3, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<3, T, P> operator*(vec<3, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator*(T scalar, vec<3, T, P> const & v); - template + template GLM_FUNC_DECL vec<3, T, P> operator*(vec<1, T, P> const & v1, vec<3, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator*(vec<3, T, P> const & v1, vec<3, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator/(vec<3, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<3, T, P> operator/(vec<3, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator/(T scalar, vec<3, T, P> const & v); - template + template GLM_FUNC_DECL vec<3, T, P> operator/(vec<1, T, P> const & v1, vec<3, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator/(vec<3, T, P> const & v1, vec<3, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator%(vec<3, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<3, T, P> operator%(vec<3, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator%(T const & scalar, vec<3, T, P> const & v); - template + template GLM_FUNC_DECL vec<3, T, P> operator%(vec<1, T, P> const & v1, vec<3, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator%(vec<3, T, P> const & v1, vec<3, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator&(vec<3, T, P> const & v1, T scalar); - template + template GLM_FUNC_DECL vec<3, T, P> operator&(vec<3, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator&(T scalar, vec<3, T, P> const & v); - template + template GLM_FUNC_DECL vec<3, T, P> operator&(vec<1, T, P> const & v1, vec<3, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator&(vec<3, T, P> const & v1, vec<3, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator|(vec<3, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<3, T, P> operator|(vec<3, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator|(T scalar, vec<3, T, P> const & v); - template + template GLM_FUNC_DECL vec<3, T, P> operator|(vec<1, T, P> const & v1, vec<3, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator|(vec<3, T, P> const & v1, vec<3, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator^(vec<3, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<3, T, P> operator^(vec<3, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator^(T scalar, vec<3, T, P> const & v); - template + template GLM_FUNC_DECL vec<3, T, P> operator^(vec<1, T, P> const & v1, vec<3, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator^(vec<3, T, P> const & v1, vec<3, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator<<(vec<3, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<3, T, P> operator<<(vec<3, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator<<(T scalar, vec<3, T, P> const & v); - template + template GLM_FUNC_DECL vec<3, T, P> operator<<(vec<1, T, P> const & v1, vec<3, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator<<(vec<3, T, P> const & v1, vec<3, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator>>(vec<3, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<3, T, P> operator>>(vec<3, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator>>(T scalar, vec<3, T, P> const & v); - template + template GLM_FUNC_DECL vec<3, T, P> operator>>(vec<1, T, P> const & v1, vec<3, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator>>(vec<3, T, P> const & v1, vec<3, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, T, P> operator~(vec<3, T, P> const & v); // -- Boolean operators -- - template + template GLM_FUNC_DECL bool operator==(vec<3, T, P> const & v1, vec<3, T, P> const & v2); - template + template GLM_FUNC_DECL bool operator!=(vec<3, T, P> const & v1, vec<3, T, P> const & v2); - template + template GLM_FUNC_DECL vec<3, bool, P> operator&&(vec<3, bool, P> const & v1, vec<3, bool, P> const & v2); - template + template GLM_FUNC_DECL vec<3, bool, P> operator||(vec<3, bool, P> const & v1, vec<3, bool, P> const & v2); }//namespace glm diff --git a/glm/detail/type_vec3.inl b/glm/detail/type_vec3.inl index 06879644..3348e496 100644 --- a/glm/detail/type_vec3.inl +++ b/glm/detail/type_vec3.inl @@ -6,39 +6,39 @@ namespace glm // -- Implicit basic constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec() {} # endif//!GLM_HAS_DEFAULTED_FUNCTIONS # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(vec<3, T, P> const & v) : x(v.x), y(v.y), z(v.z) {} # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(vec<3, T, Q> const & v) : x(v.x), y(v.y), z(v.z) {} // -- Explicit basic constructors -- - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(T scalar) : x(scalar), y(scalar), z(scalar) {} - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(T _x, T _y, T _z) : x(_x), y(_y), z(_z) {} // -- Conversion scalar constructors -- - template + template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(X _x, Y _y, Z _z) : x(static_cast(_x)) @@ -46,7 +46,7 @@ namespace glm , z(static_cast(_z)) {} - template + template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(vec<1, X, P> const& _x, vec<1, Y, P> const& _y, vec<1, Z, P> const& _z) : x(static_cast(_x)) @@ -56,48 +56,48 @@ namespace glm // -- Conversion vector constructors -- - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(vec<2, A, Q> const& _xy, B _z) : x(static_cast(_xy.x)) , y(static_cast(_xy.y)) , z(static_cast(_z)) {} - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(vec<2, A, Q> const& _xy, vec<1, B, Q> const& _z) : x(static_cast(_xy.x)) , y(static_cast(_xy.y)) , z(static_cast(_z.x)) {} - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(A _x, vec<2, B, Q> const& _yz) : x(static_cast(_x)) , y(static_cast(_yz.x)) , z(static_cast(_yz.y)) {} - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(vec<1, A, Q> const& _x, vec<2, B, Q> const& _yz) : x(static_cast(_x.x)) , y(static_cast(_yz.x)) , z(static_cast(_yz.y)) {} - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(vec<3, U, Q> const& v) : x(static_cast(v.x)) , y(static_cast(v.y)) , z(static_cast(v.z)) {} - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(vec<4, U, Q> const& v) : x(static_cast(v.x)), y(static_cast(v.y)), @@ -106,14 +106,14 @@ namespace glm // -- Component accesses -- - template + template GLM_FUNC_QUALIFIER T & vec<3, T, P>::operator[](typename vec<3, T, P>::length_type i) { assert(i >= 0 && i < this->length()); return (&x)[i]; } - template + template GLM_FUNC_QUALIFIER T const & vec<3, T, P>::operator[](typename vec<3, T, P>::length_type i) const { assert(i >= 0 && i < this->length()); @@ -123,7 +123,7 @@ namespace glm // -- Unary arithmetic operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER vec<3, T, P>& vec<3, T, P>::operator=(vec<3, T, P> const & v) { this->x = v.x; @@ -133,7 +133,7 @@ namespace glm } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template + template template GLM_FUNC_QUALIFIER vec<3, T, P>& vec<3, T, P>::operator=(vec<3, U, P> const & v) { @@ -143,7 +143,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator+=(U scalar) { @@ -153,7 +153,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator+=(vec<1, U, P> const & v) { @@ -163,7 +163,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator+=(vec<3, U, P> const & v) { @@ -173,7 +173,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator-=(U scalar) { @@ -183,7 +183,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator-=(vec<1, U, P> const & v) { @@ -193,7 +193,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator-=(vec<3, U, P> const & v) { @@ -203,7 +203,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator*=(U scalar) { @@ -213,7 +213,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator*=(vec<1, U, P> const & v) { @@ -223,7 +223,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator*=(vec<3, U, P> const & v) { @@ -233,7 +233,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator/=(U v) { @@ -243,7 +243,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator/=(vec<1, U, P> const & v) { @@ -253,7 +253,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator/=(vec<3, U, P> const & v) { @@ -265,7 +265,7 @@ namespace glm // -- Increment and decrement operators -- - template + template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator++() { ++this->x; @@ -274,7 +274,7 @@ namespace glm return *this; } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator--() { --this->x; @@ -283,7 +283,7 @@ namespace glm return *this; } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> vec<3, T, P>::operator++(int) { vec<3, T, P> Result(*this); @@ -291,7 +291,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> vec<3, T, P>::operator--(int) { vec<3, T, P> Result(*this); @@ -301,7 +301,7 @@ namespace glm // -- Unary bit operators -- - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator%=(U scalar) { @@ -311,7 +311,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator%=(vec<1, U, P> const & v) { @@ -321,7 +321,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator%=(vec<3, U, P> const & v) { @@ -331,7 +331,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator&=(U scalar) { @@ -341,7 +341,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator&=(vec<1, U, P> const & v) { @@ -351,7 +351,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator&=(vec<3, U, P> const & v) { @@ -361,7 +361,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator|=(U scalar) { @@ -371,7 +371,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator|=(vec<1, U, P> const & v) { @@ -381,7 +381,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator|=(vec<3, U, P> const & v) { @@ -391,7 +391,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator^=(U scalar) { @@ -401,7 +401,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator^=(vec<1, U, P> const & v) { @@ -411,7 +411,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator^=(vec<3, U, P> const & v) { @@ -421,7 +421,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator<<=(U scalar) { @@ -431,7 +431,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator<<=(vec<1, U, P> const & v) { @@ -441,7 +441,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator<<=(vec<3, U, P> const & v) { @@ -451,7 +451,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator>>=(U scalar) { @@ -461,7 +461,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator>>=(vec<1, U, P> const & v) { @@ -471,7 +471,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator>>=(vec<3, U, P> const & v) { @@ -483,13 +483,13 @@ namespace glm // -- Unary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator+(vec<3, T, P> const & v) { return v; } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator-(vec<3, T, P> const & v) { return vec<3, T, P>( @@ -500,7 +500,7 @@ namespace glm // -- Binary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator+(vec<3, T, P> const & v, T scalar) { return vec<3, T, P>( @@ -509,7 +509,7 @@ namespace glm v.z + scalar); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator+(vec<3, T, P> const & v, vec<1, T, P> const & scalar) { return vec<3, T, P>( @@ -518,7 +518,7 @@ namespace glm v.z + scalar.x); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator+(T scalar, vec<3, T, P> const & v) { return vec<3, T, P>( @@ -527,7 +527,7 @@ namespace glm scalar + v.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator+(vec<1, T, P> const & scalar, vec<3, T, P> const & v) { return vec<3, T, P>( @@ -536,7 +536,7 @@ namespace glm scalar.x + v.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator+(vec<3, T, P> const & v1, vec<3, T, P> const & v2) { return vec<3, T, P>( @@ -545,7 +545,7 @@ namespace glm v1.z + v2.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator-(vec<3, T, P> const & v, T scalar) { return vec<3, T, P>( @@ -554,7 +554,7 @@ namespace glm v.z - scalar); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator-(vec<3, T, P> const & v, vec<1, T, P> const & scalar) { return vec<3, T, P>( @@ -563,7 +563,7 @@ namespace glm v.z - scalar.x); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator-(T scalar, vec<3, T, P> const & v) { return vec<3, T, P>( @@ -572,7 +572,7 @@ namespace glm scalar - v.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator-(vec<1, T, P> const & scalar, vec<3, T, P> const & v) { return vec<3, T, P>( @@ -581,7 +581,7 @@ namespace glm scalar.x - v.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator-(vec<3, T, P> const & v1, vec<3, T, P> const & v2) { return vec<3, T, P>( @@ -590,7 +590,7 @@ namespace glm v1.z - v2.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator*(vec<3, T, P> const & v, T scalar) { return vec<3, T, P>( @@ -599,7 +599,7 @@ namespace glm v.z * scalar); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator*(vec<3, T, P> const & v, vec<1, T, P> const & scalar) { return vec<3, T, P>( @@ -608,7 +608,7 @@ namespace glm v.z * scalar.x); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator*(T scalar, vec<3, T, P> const & v) { return vec<3, T, P>( @@ -617,7 +617,7 @@ namespace glm scalar * v.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator*(vec<1, T, P> const & scalar, vec<3, T, P> const & v) { return vec<3, T, P>( @@ -626,7 +626,7 @@ namespace glm scalar.x * v.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator*(vec<3, T, P> const & v1, vec<3, T, P> const & v2) { return vec<3, T, P>( @@ -635,7 +635,7 @@ namespace glm v1.z * v2.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator/(vec<3, T, P> const & v, T scalar) { return vec<3, T, P>( @@ -644,7 +644,7 @@ namespace glm v.z / scalar); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator/(vec<3, T, P> const & v, vec<1, T, P> const & scalar) { return vec<3, T, P>( @@ -653,7 +653,7 @@ namespace glm v.z / scalar.x); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator/(T scalar, vec<3, T, P> const & v) { return vec<3, T, P>( @@ -662,7 +662,7 @@ namespace glm scalar / v.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator/(vec<1, T, P> const & scalar, vec<3, T, P> const & v) { return vec<3, T, P>( @@ -671,7 +671,7 @@ namespace glm scalar.x / v.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator/(vec<3, T, P> const & v1, vec<3, T, P> const & v2) { return vec<3, T, P>( @@ -682,7 +682,7 @@ namespace glm // -- Binary bit operators -- - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator%(vec<3, T, P> const & v, T scalar) { return vec<3, T, P>( @@ -691,7 +691,7 @@ namespace glm v.z % scalar); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator%(vec<3, T, P> const & v, vec<1, T, P> const & scalar) { return vec<3, T, P>( @@ -700,7 +700,7 @@ namespace glm v.z % scalar.x); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator%(T scalar, vec<3, T, P> const & v) { return vec<3, T, P>( @@ -709,7 +709,7 @@ namespace glm scalar % v.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator%(vec<1, T, P> const & scalar, vec<3, T, P> const & v) { return vec<3, T, P>( @@ -718,7 +718,7 @@ namespace glm scalar.x % v.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator%(vec<3, T, P> const & v1, vec<3, T, P> const & v2) { return vec<3, T, P>( @@ -727,7 +727,7 @@ namespace glm v1.z % v2.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator&(vec<3, T, P> const & v, T scalar) { return vec<3, T, P>( @@ -736,7 +736,7 @@ namespace glm v.z & scalar); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator&(vec<3, T, P> const & v, vec<1, T, P> const & scalar) { return vec<3, T, P>( @@ -745,7 +745,7 @@ namespace glm v.z & scalar.x); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator&(T scalar, vec<3, T, P> const & v) { return vec<3, T, P>( @@ -754,7 +754,7 @@ namespace glm scalar & v.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator&(vec<1, T, P> const & scalar, vec<3, T, P> const & v) { return vec<3, T, P>( @@ -763,7 +763,7 @@ namespace glm scalar.x & v.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator&(vec<3, T, P> const & v1, vec<3, T, P> const & v2) { return vec<3, T, P>( @@ -772,7 +772,7 @@ namespace glm v1.z & v2.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator|(vec<3, T, P> const & v, T scalar) { return vec<3, T, P>( @@ -781,7 +781,7 @@ namespace glm v.z | scalar); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator|(vec<3, T, P> const & v, vec<1, T, P> const & scalar) { return vec<3, T, P>( @@ -790,7 +790,7 @@ namespace glm v.z | scalar.x); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator|(T scalar, vec<3, T, P> const & v) { return vec<3, T, P>( @@ -799,7 +799,7 @@ namespace glm scalar | v.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator|(vec<1, T, P> const & scalar, vec<3, T, P> const & v) { return vec<3, T, P>( @@ -808,7 +808,7 @@ namespace glm scalar.x | v.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator|(vec<3, T, P> const & v1, vec<3, T, P> const & v2) { return vec<3, T, P>( @@ -817,7 +817,7 @@ namespace glm v1.z | v2.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator^(vec<3, T, P> const & v, T scalar) { return vec<3, T, P>( @@ -826,7 +826,7 @@ namespace glm v.z ^ scalar); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator^(vec<3, T, P> const & v, vec<1, T, P> const & scalar) { return vec<3, T, P>( @@ -835,7 +835,7 @@ namespace glm v.z ^ scalar.x); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator^(T scalar, vec<3, T, P> const & v) { return vec<3, T, P>( @@ -844,7 +844,7 @@ namespace glm scalar ^ v.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator^(vec<1, T, P> const & scalar, vec<3, T, P> const & v) { return vec<3, T, P>( @@ -853,7 +853,7 @@ namespace glm scalar.x ^ v.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator^(vec<3, T, P> const & v1, vec<3, T, P> const & v2) { return vec<3, T, P>( @@ -862,7 +862,7 @@ namespace glm v1.z ^ v2.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator<<(vec<3, T, P> const & v, T scalar) { return vec<3, T, P>( @@ -871,7 +871,7 @@ namespace glm v.z << scalar); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator<<(vec<3, T, P> const & v, vec<1, T, P> const & scalar) { return vec<3, T, P>( @@ -880,7 +880,7 @@ namespace glm v.z << scalar.x); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator<<(T scalar, vec<3, T, P> const & v) { return vec<3, T, P>( @@ -889,7 +889,7 @@ namespace glm scalar << v.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator<<(vec<1, T, P> const & scalar, vec<3, T, P> const & v) { return vec<3, T, P>( @@ -898,7 +898,7 @@ namespace glm scalar.x << v.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator<<(vec<3, T, P> const & v1, vec<3, T, P> const & v2) { return vec<3, T, P>( @@ -907,7 +907,7 @@ namespace glm v1.z << v2.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator>>(vec<3, T, P> const & v, T scalar) { return vec<3, T, P>( @@ -916,7 +916,7 @@ namespace glm v.z >> scalar); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator>>(vec<3, T, P> const & v, vec<1, T, P> const & scalar) { return vec<3, T, P>( @@ -925,7 +925,7 @@ namespace glm v.z >> scalar.x); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator>>(T scalar, vec<3, T, P> const & v) { return vec<3, T, P>( @@ -934,7 +934,7 @@ namespace glm scalar >> v.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator>>(vec<1, T, P> const & scalar, vec<3, T, P> const & v) { return vec<3, T, P>( @@ -943,7 +943,7 @@ namespace glm scalar.x >> v.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator>>(vec<3, T, P> const & v1, vec<3, T, P> const & v2) { return vec<3, T, P>( @@ -952,7 +952,7 @@ namespace glm v1.z >> v2.z); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator~(vec<3, T, P> const & v) { return vec<3, T, P>( @@ -963,7 +963,7 @@ namespace glm // -- Boolean operators -- - template + template GLM_FUNC_QUALIFIER bool operator==(vec<3, T, P> const & v1, vec<3, T, P> const & v2) { return @@ -972,19 +972,19 @@ namespace glm detail::compute_equal::call(v1.z, v2.z); } - template + template GLM_FUNC_QUALIFIER bool operator!=(vec<3, T, P> const & v1, vec<3, T, P> const & v2) { return !(v1 == v2); } - template + template GLM_FUNC_QUALIFIER vec<3, bool, P> operator&&(vec<3, bool, P> const & v1, vec<3, bool, P> const & v2) { return vec<3, bool, P>(v1.x && v2.x, v1.y && v2.y, v1.z && v2.z); } - template + template GLM_FUNC_QUALIFIER vec<3, bool, P> operator||(vec<3, bool, P> const & v1, vec<3, bool, P> const & v2) { return vec<3, bool, P>(v1.x || v2.x, v1.y || v2.y, v1.z || v2.z); diff --git a/glm/detail/type_vec4.hpp b/glm/detail/type_vec4.hpp index 1bc11a59..92e4b7a2 100644 --- a/glm/detail/type_vec4.hpp +++ b/glm/detail/type_vec4.hpp @@ -15,7 +15,7 @@ namespace glm { - template + template struct vec<4, T, P> { // -- Implementation detail -- @@ -91,7 +91,7 @@ namespace glm GLM_FUNC_DECL GLM_CONSTEXPR_SIMD vec() GLM_DEFAULT; GLM_FUNC_DECL GLM_CONSTEXPR_SIMD vec(vec<4, T, P> const& v) GLM_DEFAULT; - template + template GLM_FUNC_DECL GLM_CONSTEXPR_SIMD vec(vec<4, T, Q> const& v); // -- Explicit basic constructors -- @@ -110,41 +110,41 @@ namespace glm // -- Conversion vector constructors -- /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<2, A, Q> const& _xy, B _z, C _w); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<2, A, Q> const& _xy, vec<1, B, Q> const& _z, vec<1, C, Q> const& _w); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(A _x, vec<2, B, Q> const& _yz, C _w); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<1, A, Q> const& _x, vec<2, B, Q> const& _yz, vec<1, C, Q> const& _w); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(A _x, B _y, vec<2, C, Q> const& _zw); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<1, A, Q> const& _x, vec<1, B, Q> const& _y, vec<2, C, Q> const& _zw); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<3, A, Q> const& _xyz, B _w); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<3, A, Q> const& _xyz, vec<1, B, Q> const& _w); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(A _x, vec<3, B, Q> const& _yzw); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<1, A, Q> const& _x, vec<3, B, Q> const& _yzw); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<2, A, Q> const& _xy, vec<2, B, Q> const& _zw); /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) - template + template GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<4, U, Q> const& v); // -- Swizzle constructors -- @@ -272,179 +272,179 @@ namespace glm // -- Unary operators -- - template + template GLM_FUNC_DECL vec<4, T, P> operator+(vec<4, T, P> const & v); - template + template GLM_FUNC_DECL vec<4, T, P> operator-(vec<4, T, P> const & v); // -- Binary operators -- - template + template GLM_FUNC_DECL vec<4, T, P> operator+(vec<4, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<4, T, P> operator+(vec<4, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<4, T, P> operator+(T scalar, vec<4, T, P> const & v); - template + template GLM_FUNC_DECL vec<4, T, P> operator+(vec<1, T, P> const & v1, vec<4, T, P> const & v2); - template + template GLM_FUNC_DECL vec<4, T, P> operator+(vec<4, T, P> const & v1, vec<4, T, P> const & v2); - template + template GLM_FUNC_DECL vec<4, T, P> operator-(vec<4, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<4, T, P> operator-(vec<4, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<4, T, P> operator-(T scalar, vec<4, T, P> const & v); - template + template GLM_FUNC_DECL vec<4, T, P> operator-(vec<1, T, P> const & v1, vec<4, T, P> const & v2); - template + template GLM_FUNC_DECL vec<4, T, P> operator-(vec<4, T, P> const & v1, vec<4, T, P> const & v2); - template + template GLM_FUNC_DECL vec<4, T, P> operator*(vec<4, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<4, T, P> operator*(vec<4, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<4, T, P> operator*(T scalar, vec<4, T, P> const & v); - template + template GLM_FUNC_DECL vec<4, T, P> operator*(vec<1, T, P> const & v1, vec<4, T, P> const & v2); - template + template GLM_FUNC_DECL vec<4, T, P> operator*(vec<4, T, P> const & v1, vec<4, T, P> const & v2); - template + template GLM_FUNC_DECL vec<4, T, P> operator/(vec<4, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<4, T, P> operator/(vec<4, T, P> const & v1, vec<1, T, P> const & v2); - template + template GLM_FUNC_DECL vec<4, T, P> operator/(T scalar, vec<4, T, P> const & v); - template + template GLM_FUNC_DECL vec<4, T, P> operator/(vec<1, T, P> const & v1, vec<4, T, P> const & v2); - template + template GLM_FUNC_DECL vec<4, T, P> operator/(vec<4, T, P> const & v1, vec<4, T, P> const & v2); - template + template GLM_FUNC_DECL vec<4, T, P> operator%(vec<4, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<4, T, P> operator%(vec<4, T, P> const & v, vec<1, T, P> const & scalar); - template + template GLM_FUNC_DECL vec<4, T, P> operator%(T scalar, vec<4, T, P> const & v); - template + template GLM_FUNC_DECL vec<4, T, P> operator%(vec<1, T, P> const & scalar, vec<4, T, P> const & v); - template + template GLM_FUNC_DECL vec<4, T, P> operator%(vec<4, T, P> const & v1, vec<4, T, P> const & v2); - template + template GLM_FUNC_DECL vec<4, T, P> operator&(vec<4, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<4, T, P> operator&(vec<4, T, P> const & v, vec<1, T, P> const & scalar); - template + template GLM_FUNC_DECL vec<4, T, P> operator&(T scalar, vec<4, T, P> const & v); - template + template GLM_FUNC_DECL vec<4, T, P> operator&(vec<1, T, P> const & scalar, vec<4, T, P> const & v); - template + template GLM_FUNC_DECL vec<4, T, P> operator&(vec<4, T, P> const & v1, vec<4, T, P> const & v2); - template + template GLM_FUNC_DECL vec<4, T, P> operator|(vec<4, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<4, T, P> operator|(vec<4, T, P> const & v, vec<1, T, P> const & scalar); - template + template GLM_FUNC_DECL vec<4, T, P> operator|(T scalar, vec<4, T, P> const & v); - template + template GLM_FUNC_DECL vec<4, T, P> operator|(vec<1, T, P> const & scalar, vec<4, T, P> const & v); - template + template GLM_FUNC_DECL vec<4, T, P> operator|(vec<4, T, P> const & v1, vec<4, T, P> const & v2); - template + template GLM_FUNC_DECL vec<4, T, P> operator^(vec<4, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<4, T, P> operator^(vec<4, T, P> const & v, vec<1, T, P> const & scalar); - template + template GLM_FUNC_DECL vec<4, T, P> operator^(T scalar, vec<4, T, P> const & v); - template + template GLM_FUNC_DECL vec<4, T, P> operator^(vec<1, T, P> const & scalar, vec<4, T, P> const & v); - template + template GLM_FUNC_DECL vec<4, T, P> operator^(vec<4, T, P> const & v1, vec<4, T, P> const & v2); - template + template GLM_FUNC_DECL vec<4, T, P> operator<<(vec<4, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<4, T, P> operator<<(vec<4, T, P> const & v, vec<1, T, P> const & scalar); - template + template GLM_FUNC_DECL vec<4, T, P> operator<<(T scalar, vec<4, T, P> const & v); - template + template GLM_FUNC_DECL vec<4, T, P> operator<<(vec<1, T, P> const & scalar, vec<4, T, P> const & v); - template + template GLM_FUNC_DECL vec<4, T, P> operator<<(vec<4, T, P> const & v1, vec<4, T, P> const & v2); - template + template GLM_FUNC_DECL vec<4, T, P> operator>>(vec<4, T, P> const & v, T scalar); - template + template GLM_FUNC_DECL vec<4, T, P> operator>>(vec<4, T, P> const & v, vec<1, T, P> const & scalar); - template + template GLM_FUNC_DECL vec<4, T, P> operator>>(T scalar, vec<4, T, P> const & v); - template + template GLM_FUNC_DECL vec<4, T, P> operator>>(vec<1, T, P> const & scalar, vec<4, T, P> const & v); - template + template GLM_FUNC_DECL vec<4, T, P> operator>>(vec<4, T, P> const & v1, vec<4, T, P> const & v2); - template + template GLM_FUNC_DECL vec<4, T, P> operator~(vec<4, T, P> const & v); // -- Boolean operators -- - template + template GLM_FUNC_DECL bool operator==(vec<4, T, P> const & v1, vec<4, T, P> const & v2); - template + template GLM_FUNC_DECL bool operator!=(vec<4, T, P> const & v1, vec<4, T, P> const & v2); - template + template GLM_FUNC_DECL vec<4, bool, P> operator&&(vec<4, bool, P> const & v1, vec<4, bool, P> const & v2); - template + template GLM_FUNC_DECL vec<4, bool, P> operator||(vec<4, bool, P> const & v1, vec<4, bool, P> const & v2); }//namespace glm diff --git a/glm/detail/type_vec4.inl b/glm/detail/type_vec4.inl index fd214545..84f22a1a 100644 --- a/glm/detail/type_vec4.inl +++ b/glm/detail/type_vec4.inl @@ -34,7 +34,7 @@ namespace detail enum test {value = ~0}; }; - template + template struct compute_vec4_add { GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b) @@ -43,7 +43,7 @@ namespace detail } }; - template + template struct compute_vec4_sub { GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b) @@ -52,7 +52,7 @@ namespace detail } }; - template + template struct compute_vec4_mul { GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b) @@ -61,7 +61,7 @@ namespace detail } }; - template + template struct compute_vec4_div { GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b) @@ -70,7 +70,7 @@ namespace detail } }; - template + template struct compute_vec4_mod { GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b) @@ -79,7 +79,7 @@ namespace detail } }; - template + template struct compute_vec4_and { GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b) @@ -88,7 +88,7 @@ namespace detail } }; - template + template struct compute_vec4_or { GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b) @@ -97,7 +97,7 @@ namespace detail } }; - template + template struct compute_vec4_xor { GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b) @@ -106,7 +106,7 @@ namespace detail } }; - template + template struct compute_vec4_shift_left { GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b) @@ -115,7 +115,7 @@ namespace detail } }; - template + template struct compute_vec4_shift_right { GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b) @@ -124,7 +124,7 @@ namespace detail } }; - template + template struct compute_vec4_equal { GLM_FUNC_QUALIFIER static bool call(vec<4, T, P> const & v1, vec<4, T, P> const & v2) @@ -137,7 +137,7 @@ namespace detail } }; - template + template struct compute_vec4_nequal { GLM_FUNC_QUALIFIER static bool call(vec<4, T, P> const & v1, vec<4, T, P> const & v2) @@ -146,7 +146,7 @@ namespace detail } }; - template + template struct compute_vec4_bitwise_not { GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & v) @@ -159,39 +159,39 @@ namespace detail // -- Implicit basic constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, P>::vec() {} # endif//!GLM_HAS_DEFAULTED_FUNCTIONS # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, P>::vec(vec<4, T, P> const & v) : x(v.x), y(v.y), z(v.z), w(v.w) {} # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, P>::vec(vec<4, T, Q> const & v) : x(v.x), y(v.y), z(v.z), w(v.w) {} // -- Explicit basic constructors -- - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, P>::vec(T scalar) : x(scalar), y(scalar), z(scalar), w(scalar) {} - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, P>::vec(T _x, T _y, T _z, T _w) : x(_x), y(_y), z(_z), w(_w) {} // -- Conversion scalar constructors -- - template + template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, P>::vec(X _x, Y _y, Z _z, W _w) : x(static_cast(_x)) @@ -200,7 +200,7 @@ namespace detail , w(static_cast(_w)) {} - template + template template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(vec<1, X, P> const& _x, vec<1, Y, P> const& _y, vec<1, Z, P> const& _z, vec<1, W, P> const& _w) : x(static_cast(_x.x)) @@ -211,8 +211,8 @@ namespace detail // -- Conversion vector constructors -- - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(vec<2, A, Q> const& _xy, B _z, C _w) : x(static_cast(_xy.x)) , y(static_cast(_xy.y)) @@ -220,8 +220,8 @@ namespace detail , w(static_cast(_w)) {} - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(vec<2, A, Q> const& _xy, vec<1, B, Q> const& _z, vec<1, C, Q> const& _w) : x(static_cast(_xy.x)) , y(static_cast(_xy.y)) @@ -229,8 +229,8 @@ namespace detail , w(static_cast(_w.x)) {} - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(A _x, vec<2, B, Q> const& _yz, C _w) : x(static_cast(_x)) , y(static_cast(_yz.x)) @@ -238,8 +238,8 @@ namespace detail , w(static_cast(_w)) {} - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(vec<1, A, Q> const& _x, vec<2, B, Q> const& _yz, vec<1, C, Q> const& _w) : x(static_cast(_x.x)) , y(static_cast(_yz.x)) @@ -247,8 +247,8 @@ namespace detail , w(static_cast(_w.x)) {} - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(A _x, B _y, vec<2, C, Q> const& _zw) : x(static_cast(_x)) , y(static_cast(_y)) @@ -256,8 +256,8 @@ namespace detail , w(static_cast(_zw.y)) {} - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(vec<1, A, Q> const& _x, vec<1, B, Q> const& _y, vec<2, C, Q> const& _zw) : x(static_cast(_x.x)) , y(static_cast(_y.x)) @@ -265,8 +265,8 @@ namespace detail , w(static_cast(_zw.y)) {} - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(vec<3, A, Q> const& _xyz, B _w) : x(static_cast(_xyz.x)), y(static_cast(_xyz.y)), @@ -274,8 +274,8 @@ namespace detail w(static_cast(_w)) {} - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(vec<3, A, Q> const& _xyz, vec<1, B, Q> const& _w) : x(static_cast(_xyz.x)), y(static_cast(_xyz.y)), @@ -283,8 +283,8 @@ namespace detail w(static_cast(_w.x)) {} - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(A _x, vec<3, B, Q> const& _yzw) : x(static_cast(_x)), y(static_cast(_yzw.x)), @@ -292,8 +292,8 @@ namespace detail w(static_cast(_yzw.z)) {} - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(vec<1, A, Q> const& _x, vec<3, B, Q> const& _yzw) : x(static_cast(_x.x)), y(static_cast(_yzw.x)), @@ -301,8 +301,8 @@ namespace detail w(static_cast(_yzw.z)) {} - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(vec<2, A, Q> const& _xy, vec<2, B, Q> const& _zw) : x(static_cast(_xy.x)), y(static_cast(_xy.y)), @@ -310,8 +310,8 @@ namespace detail w(static_cast(_zw.y)) {} - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(vec<4, U, Q> const& v) : x(static_cast(v.x)), y(static_cast(v.y)), @@ -321,14 +321,14 @@ namespace detail // -- Component accesses -- - template + template GLM_FUNC_QUALIFIER T& vec<4, T, P>::operator[](typename vec<4, T, P>::length_type i) { assert(i >= 0 && i < this->length()); return (&x)[i]; } - template + template GLM_FUNC_QUALIFIER T const& vec<4, T, P>::operator[](typename vec<4, T, P>::length_type i) const { assert(i >= 0 && i < this->length()); @@ -338,7 +338,7 @@ namespace detail // -- Unary arithmetic operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER vec<4, T, P>& vec<4, T, P>::operator=(vec<4, T, P> const & v) { this->x = v.x; @@ -349,7 +349,7 @@ namespace detail } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template + template template GLM_FUNC_QUALIFIER vec<4, T, P>& vec<4, T, P>::operator=(vec<4, U, P> const & v) { @@ -360,84 +360,84 @@ namespace detail return *this; } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator+=(U scalar) { return (*this = detail::compute_vec4_add::value>::call(*this, vec<4, T, P>(scalar))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator+=(vec<1, U, P> const & v) { return (*this = detail::compute_vec4_add::value>::call(*this, vec<4, T, P>(v.x))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator+=(vec<4, U, P> const & v) { return (*this = detail::compute_vec4_add::value>::call(*this, vec<4, T, P>(v))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator-=(U scalar) { return (*this = detail::compute_vec4_sub::value>::call(*this, vec<4, T, P>(scalar))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator-=(vec<1, U, P> const & v) { return (*this = detail::compute_vec4_sub::value>::call(*this, vec<4, T, P>(v.x))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator-=(vec<4, U, P> const & v) { return (*this = detail::compute_vec4_sub::value>::call(*this, vec<4, T, P>(v))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator*=(U scalar) { return (*this = detail::compute_vec4_mul::value>::call(*this, vec<4, T, P>(scalar))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator*=(vec<1, U, P> const & v) { return (*this = detail::compute_vec4_mul::value>::call(*this, vec<4, T, P>(v.x))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator*=(vec<4, U, P> const & v) { return (*this = detail::compute_vec4_mul::value>::call(*this, vec<4, T, P>(v))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator/=(U scalar) { return (*this = detail::compute_vec4_div::value>::call(*this, vec<4, T, P>(scalar))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator/=(vec<1, U, P> const & v) { return (*this = detail::compute_vec4_div::value>::call(*this, vec<4, T, P>(v.x))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator/=(vec<4, U, P> const & v) { @@ -446,7 +446,7 @@ namespace detail // -- Increment and decrement operators -- - template + template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator++() { ++this->x; @@ -456,7 +456,7 @@ namespace detail return *this; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator--() { --this->x; @@ -466,7 +466,7 @@ namespace detail return *this; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> vec<4, T, P>::operator++(int) { vec<4, T, P> Result(*this); @@ -474,7 +474,7 @@ namespace detail return Result; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> vec<4, T, P>::operator--(int) { vec<4, T, P> Result(*this); @@ -484,126 +484,126 @@ namespace detail // -- Unary bit operators -- - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator%=(U scalar) { return (*this = detail::compute_vec4_mod::value>::call(*this, vec<4, T, P>(scalar))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator%=(vec<1, U, P> const& v) { return (*this = detail::compute_vec4_mod::value>::call(*this, vec<4, T, P>(v))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator%=(vec<4, U, P> const& v) { return (*this = detail::compute_vec4_mod::value>::call(*this, vec<4, T, P>(v))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator&=(U scalar) { return (*this = detail::compute_vec4_and::value, sizeof(T) * 8, detail::is_aligned

::value>::call(*this, vec<4, T, P>(scalar))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator&=(vec<1, U, P> const & v) { return (*this = detail::compute_vec4_and::value, sizeof(T) * 8, detail::is_aligned

::value>::call(*this, vec<4, T, P>(v))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator&=(vec<4, U, P> const & v) { return (*this = detail::compute_vec4_and::value, sizeof(T) * 8, detail::is_aligned

::value>::call(*this, vec<4, T, P>(v))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator|=(U scalar) { return (*this = detail::compute_vec4_or::value, sizeof(T) * 8, detail::is_aligned

::value>::call(*this, vec<4, T, P>(scalar))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator|=(vec<1, U, P> const & v) { return (*this = detail::compute_vec4_or::value, sizeof(T) * 8, detail::is_aligned

::value>::call(*this, vec<4, T, P>(v))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator|=(vec<4, U, P> const & v) { return (*this = detail::compute_vec4_or::value, sizeof(T) * 8, detail::is_aligned

::value>::call(*this, vec<4, T, P>(v))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator^=(U scalar) { return (*this = detail::compute_vec4_xor::value, sizeof(T) * 8, detail::is_aligned

::value>::call(*this, vec<4, T, P>(scalar))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator^=(vec<1, U, P> const & v) { return (*this = detail::compute_vec4_xor::value, sizeof(T) * 8, detail::is_aligned

::value>::call(*this, vec<4, T, P>(v))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator^=(vec<4, U, P> const & v) { return (*this = detail::compute_vec4_xor::value, sizeof(T) * 8, detail::is_aligned

::value>::call(*this, vec<4, T, P>(v))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator<<=(U scalar) { return (*this = detail::compute_vec4_shift_left::value, sizeof(T) * 8, detail::is_aligned

::value>::call(*this, vec<4, T, P>(scalar))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator<<=(vec<1, U, P> const & v) { return (*this = detail::compute_vec4_shift_left::value, sizeof(T) * 8, detail::is_aligned

::value>::call(*this, vec<4, T, P>(v))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator<<=(vec<4, U, P> const & v) { return (*this = detail::compute_vec4_shift_left::value, sizeof(T) * 8, detail::is_aligned

::value>::call(*this, vec<4, T, P>(v))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator>>=(U scalar) { return (*this = detail::compute_vec4_shift_right::value, sizeof(T) * 8, detail::is_aligned

::value>::call(*this, vec<4, T, P>(scalar))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator>>=(vec<1, U, P> const & v) { return (*this = detail::compute_vec4_shift_right::value, sizeof(T) * 8, detail::is_aligned

::value>::call(*this, vec<4, T, P>(v))); } - template + template template GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator>>=(vec<4, U, P> const & v) { @@ -612,13 +612,13 @@ namespace detail // -- Unary constant operators -- - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator+(vec<4, T, P> const & v) { return v; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator-(vec<4, T, P> const & v) { return vec<4, T, P>(0) -= v; @@ -626,121 +626,121 @@ namespace detail // -- Binary arithmetic operators -- - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator+(vec<4, T, P> const & v, T scalar) { return vec<4, T, P>(v) += scalar; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator+(vec<4, T, P> const & v1, vec<1, T, P> const & v2) { return vec<4, T, P>(v1) += v2; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator+(T scalar, vec<4, T, P> const & v) { return vec<4, T, P>(v) += scalar; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator+(vec<1, T, P> const & v1, vec<4, T, P> const & v2) { return vec<4, T, P>(v2) += v1; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator+(vec<4, T, P> const & v1, vec<4, T, P> const & v2) { return vec<4, T, P>(v1) += v2; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator-(vec<4, T, P> const & v, T scalar) { return vec<4, T, P>(v) -= scalar; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator-(vec<4, T, P> const & v1, vec<1, T, P> const & v2) { return vec<4, T, P>(v1) -= v2; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator-(T scalar, vec<4, T, P> const & v) { return vec<4, T, P>(scalar) -= v; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator-(vec<1, T, P> const & v1, vec<4, T, P> const & v2) { return vec<4, T, P>(v1.x) -= v2; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator-(vec<4, T, P> const & v1, vec<4, T, P> const & v2) { return vec<4, T, P>(v1) -= v2; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator*(vec<4, T, P> const & v, T scalar) { return vec<4, T, P>(v) *= scalar; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator*(vec<4, T, P> const & v1, vec<1, T, P> const & v2) { return vec<4, T, P>(v1) *= v2; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator*(T scalar, vec<4, T, P> const & v) { return vec<4, T, P>(v) *= scalar; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator*(vec<1, T, P> const & v1, vec<4, T, P> const & v2) { return vec<4, T, P>(v2) *= v1; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator*(vec<4, T, P> const & v1, vec<4, T, P> const & v2) { return vec<4, T, P>(v1) *= v2; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator/(vec<4, T, P> const & v, T scalar) { return vec<4, T, P>(v) /= scalar; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator/(vec<4, T, P> const & v1, vec<1, T, P> const & v2) { return vec<4, T, P>(v1) /= v2; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator/(T scalar, vec<4, T, P> const & v) { return vec<4, T, P>(scalar) /= v; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator/(vec<1, T, P> const & v1, vec<4, T, P> const & v2) { return vec<4, T, P>(v1.x) /= v2; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator/(vec<4, T, P> const & v1, vec<4, T, P> const & v2) { return vec<4, T, P>(v1) /= v2; @@ -748,187 +748,187 @@ namespace detail // -- Binary bit operators -- - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator%(vec<4, T, P> const & v, T scalar) { return vec<4, T, P>(v) %= scalar; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator%(vec<4, T, P> const & v1, vec<1, T, P> const & v2) { return vec<4, T, P>(v1) %= v2.x; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator%(T scalar, vec<4, T, P> const & v) { return vec<4, T, P>(scalar) %= v; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator%(vec<1, T, P> const & scalar, vec<4, T, P> const & v) { return vec<4, T, P>(scalar.x) %= v; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator%(vec<4, T, P> const & v1, vec<4, T, P> const & v2) { return vec<4, T, P>(v1) %= v2; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator&(vec<4, T, P> const & v, T scalar) { return vec<4, T, P>(v) &= scalar; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator&(vec<4, T, P> const & v, vec<1, T, P> const & scalar) { return vec<4, T, P>(v) &= scalar; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator&(T scalar, vec<4, T, P> const & v) { return vec<4, T, P>(scalar) &= v; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator&(vec<1, T, P> const & v1, vec<4, T, P> const & v2) { return vec<4, T, P>(v1.x) &= v2; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator&(vec<4, T, P> const & v1, vec<4, T, P> const & v2) { return vec<4, T, P>(v1) &= v2; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator|(vec<4, T, P> const & v, T scalar) { return vec<4, T, P>(v) |= scalar; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator|(vec<4, T, P> const & v1, vec<1, T, P> const & v2) { return vec<4, T, P>(v1) |= v2.x; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator|(T scalar, vec<4, T, P> const & v) { return vec<4, T, P>(scalar) |= v; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator|(vec<1, T, P> const & v1, vec<4, T, P> const & v2) { return vec<4, T, P>(v1.x) |= v2; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator|(vec<4, T, P> const & v1, vec<4, T, P> const & v2) { return vec<4, T, P>(v1) |= v2; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator^(vec<4, T, P> const & v, T scalar) { return vec<4, T, P>(v) ^= scalar; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator^(vec<4, T, P> const & v1, vec<1, T, P> const & v2) { return vec<4, T, P>(v1) ^= v2.x; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator^(T scalar, vec<4, T, P> const & v) { return vec<4, T, P>(scalar) ^= v; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator^(vec<1, T, P> const & v1, vec<4, T, P> const & v2) { return vec<4, T, P>(v1.x) ^= v2; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator^(vec<4, T, P> const & v1, vec<4, T, P> const & v2) { return vec<4, T, P>(v1) ^= v2; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator<<(vec<4, T, P> const & v, T scalar) { return vec<4, T, P>(v) <<= scalar; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator<<(vec<4, T, P> const & v1, vec<1, T, P> const & v2) { return vec<4, T, P>(v1) <<= v2.x; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator<<(T scalar, vec<4, T, P> const & v) { return vec<4, T, P>(scalar) <<= v; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator<<(vec<1, T, P> const & v1, vec<4, T, P> const & v2) { return vec<4, T, P>(v1.x) <<= v2; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator<<(vec<4, T, P> const & v1, vec<4, T, P> const & v2) { return vec<4, T, P>(v1) <<= v2; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator>>(vec<4, T, P> const & v, T scalar) { return vec<4, T, P>(v) >>= scalar; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator>>(vec<4, T, P> const & v1, vec<1, T, P> const & v2) { return vec<4, T, P>(v1) >>= v2.x; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator>>(T scalar, vec<4, T, P> const & v) { return vec<4, T, P>(scalar) >>= v; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator>>(vec<1, T, P> const & v1, vec<4, T, P> const & v2) { return vec<4, T, P>(v1.x) >>= v2; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator>>(vec<4, T, P> const & v1, vec<4, T, P> const & v2) { return vec<4, T, P>(v1) >>= v2; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator~(vec<4, T, P> const & v) { return detail::compute_vec4_bitwise_not::value, sizeof(T) * 8, detail::is_aligned

::value>::call(v); @@ -936,25 +936,25 @@ namespace detail // -- Boolean operators -- - template + template GLM_FUNC_QUALIFIER bool operator==(vec<4, T, P> const & v1, vec<4, T, P> const & v2) { return detail::compute_vec4_equal::value, sizeof(T) * 8, detail::is_aligned

::value>::call(v1, v2); } - template + template GLM_FUNC_QUALIFIER bool operator!=(vec<4, T, P> const & v1, vec<4, T, P> const & v2) { return detail::compute_vec4_nequal::value, sizeof(T) * 8, detail::is_aligned

::value>::call(v1, v2); } - template + template GLM_FUNC_QUALIFIER vec<4, bool, P> operator&&(vec<4, bool, P> const & v1, vec<4, bool, P> const & v2) { return vec<4, bool, P>(v1.x && v2.x, v1.y && v2.y, v1.z && v2.z, v1.w && v2.w); } - template + template GLM_FUNC_QUALIFIER vec<4, bool, P> operator||(vec<4, bool, P> const & v1, vec<4, bool, P> const & v2) { return vec<4, bool, P>(v1.x || v2.x, v1.y || v2.y, v1.z || v2.z, v1.w || v2.w); diff --git a/glm/detail/type_vec4_simd.inl b/glm/detail/type_vec4_simd.inl index 084e7ff2..287d6ec1 100644 --- a/glm/detail/type_vec4_simd.inl +++ b/glm/detail/type_vec4_simd.inl @@ -7,7 +7,7 @@ namespace glm{ namespace detail { # if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED - template + template struct _swizzle_base1<4, float, P, E0,E1,E2,E3, true> : public _swizzle_base0 { GLM_FUNC_QUALIFIER vec<4, float, P> operator ()() const @@ -24,7 +24,7 @@ namespace detail } }; - template + template struct _swizzle_base1<4, int32, P, E0,E1,E2,E3, true> : public _swizzle_base0 { GLM_FUNC_QUALIFIER vec<4, int32, P> operator ()() const @@ -37,7 +37,7 @@ namespace detail } }; - template + template struct _swizzle_base1<4, uint32, P, E0,E1,E2,E3, true> : public _swizzle_base0 { GLM_FUNC_QUALIFIER vec<4, uint32, P> operator ()() const @@ -51,7 +51,7 @@ namespace detail }; # endif// GLM_SWIZZLE == GLM_SWIZZLE_ENABLED - template + template struct compute_vec4_add { static vec<4, float, P> call(vec<4, float, P> const & a, vec<4, float, P> const & b) @@ -63,7 +63,7 @@ namespace detail }; # if GLM_ARCH & GLM_ARCH_AVX_BIT - template + template struct compute_vec4_add { static vec<4, double, P> call(vec<4, double, P> const & a, vec<4, double, P> const & b) @@ -75,7 +75,7 @@ namespace detail }; # endif - template + template struct compute_vec4_sub { static vec<4, float, P> call(vec<4, float, P> const & a, vec<4, float, P> const & b) @@ -87,7 +87,7 @@ namespace detail }; # if GLM_ARCH & GLM_ARCH_AVX_BIT - template + template struct compute_vec4_sub { static vec<4, double, P> call(vec<4, double, P> const & a, vec<4, double, P> const & b) @@ -99,7 +99,7 @@ namespace detail }; # endif - template + template struct compute_vec4_mul { static vec<4, float, P> call(vec<4, float, P> const & a, vec<4, float, P> const & b) @@ -111,7 +111,7 @@ namespace detail }; # if GLM_ARCH & GLM_ARCH_AVX_BIT - template + template struct compute_vec4_mul { static vec<4, double, P> call(vec<4, double, P> const & a, vec<4, double, P> const & b) @@ -123,7 +123,7 @@ namespace detail }; # endif - template + template struct compute_vec4_div { static vec<4, float, P> call(vec<4, float, P> const & a, vec<4, float, P> const & b) @@ -135,7 +135,7 @@ namespace detail }; # if GLM_ARCH & GLM_ARCH_AVX_BIT - template + template struct compute_vec4_div { static vec<4, double, P> call(vec<4, double, P> const & a, vec<4, double, P> const & b) @@ -158,7 +158,7 @@ namespace detail } }; - template + template struct compute_vec4_and { static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b) @@ -170,7 +170,7 @@ namespace detail }; # if GLM_ARCH & GLM_ARCH_AVX2_BIT - template + template struct compute_vec4_and { static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b) @@ -182,7 +182,7 @@ namespace detail }; # endif - template + template struct compute_vec4_or { static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b) @@ -194,7 +194,7 @@ namespace detail }; # if GLM_ARCH & GLM_ARCH_AVX2_BIT - template + template struct compute_vec4_or { static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b) @@ -206,7 +206,7 @@ namespace detail }; # endif - template + template struct compute_vec4_xor { static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b) @@ -218,7 +218,7 @@ namespace detail }; # if GLM_ARCH & GLM_ARCH_AVX2_BIT - template + template struct compute_vec4_xor { static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b) @@ -230,7 +230,7 @@ namespace detail }; # endif - template + template struct compute_vec4_shift_left { static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b) @@ -242,7 +242,7 @@ namespace detail }; # if GLM_ARCH & GLM_ARCH_AVX2_BIT - template + template struct compute_vec4_shift_left { static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b) @@ -254,7 +254,7 @@ namespace detail }; # endif - template + template struct compute_vec4_shift_right { static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b) @@ -266,7 +266,7 @@ namespace detail }; # if GLM_ARCH & GLM_ARCH_AVX2_BIT - template + template struct compute_vec4_shift_right { static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b) @@ -278,7 +278,7 @@ namespace detail }; # endif - template + template struct compute_vec4_bitwise_not { static vec<4, T, P> call(vec<4, T, P> const & v) @@ -290,7 +290,7 @@ namespace detail }; # if GLM_ARCH & GLM_ARCH_AVX2_BIT - template + template struct compute_vec4_bitwise_not { static vec<4, T, P> call(vec<4, T, P> const & v) @@ -302,7 +302,7 @@ namespace detail }; # endif - template + template struct compute_vec4_equal { static bool call(vec<4, float, P> const & v1, vec<4, float, P> const & v2) @@ -311,7 +311,7 @@ namespace detail } }; - template + template struct compute_vec4_equal { static bool call(vec<4, int32, P> const & v1, vec<4, int32, P> const & v2) @@ -320,7 +320,7 @@ namespace detail } }; - template + template struct compute_vec4_nequal { static bool call(vec<4, float, P> const & v1, vec<4, float, P> const & v2) @@ -329,7 +329,7 @@ namespace detail } }; - template + template struct compute_vec4_nequal { static bool call(vec<4, int32, P> const & v1, vec<4, int32, P> const & v2) diff --git a/glm/fwd.hpp b/glm/fwd.hpp index 1a08b3b7..d4c5e3fb 100644 --- a/glm/fwd.hpp +++ b/glm/fwd.hpp @@ -14,19 +14,19 @@ // GLM_GTC_quaternion namespace glm { - template struct tquat; + template struct tquat; - /// Quaternion of low single-precision floating-point numbers. + /// Quaternion of low single-qualifier floating-point numbers. /// /// @see gtc_quaternion typedef tquat lowp_quat; - /// Quaternion of medium single-precision floating-point numbers. + /// Quaternion of medium single-qualifier floating-point numbers. /// /// @see gtc_quaternion typedef tquat mediump_quat; - /// Quaternion of high single-precision floating-point numbers. + /// Quaternion of high single-qualifier floating-point numbers. /// /// @see gtc_quaternion typedef tquat highp_quat; @@ -38,42 +38,42 @@ namespace glm #elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && defined(GLM_PRECISION_LOWP_FLOAT)) typedef lowp_quat quat; #elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT)) - /// Quaternion of default single-precision floating-point numbers. + /// Quaternion of default single-qualifier floating-point numbers. typedef highp_quat quat; #endif - /// Quaternion of low single-precision floating-point numbers. + /// Quaternion of low single-qualifier floating-point numbers. /// /// @see gtc_quaternion typedef lowp_quat lowp_fquat; - /// Quaternion of medium single-precision floating-point numbers. + /// Quaternion of medium single-qualifier floating-point numbers. /// /// @see gtc_quaternion typedef mediump_quat mediump_fquat; - /// Quaternion of high single-precision floating-point numbers. + /// Quaternion of high single-qualifier floating-point numbers. /// /// @see gtc_quaternion typedef highp_quat highp_fquat; - /// Quaternion of default single-precision floating-point numbers. + /// Quaternion of default single-qualifier floating-point numbers. /// /// @see gtc_quaternion typedef quat fquat; - /// Quaternion of low double-precision floating-point numbers. + /// Quaternion of low double-qualifier floating-point numbers. /// /// @see gtc_quaternion typedef tquat lowp_dquat; - /// Quaternion of medium double-precision floating-point numbers. + /// Quaternion of medium double-qualifier floating-point numbers. /// /// @see gtc_quaternion typedef tquat mediump_dquat; - /// Quaternion of high double-precision floating-point numbers. + /// Quaternion of high double-qualifier floating-point numbers. /// /// @see gtc_quaternion typedef tquat highp_dquat; @@ -85,7 +85,7 @@ namespace glm #elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && defined(GLM_PRECISION_LOWP_DOUBLE)) typedef lowp_dquat dquat; #elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE)) - /// Quaternion of default double-precision floating-point numbers. + /// Quaternion of default double-qualifier floating-point numbers. /// /// @see gtc_quaternion typedef highp_dquat dquat; @@ -97,123 +97,123 @@ namespace glm // GLM_GTC_precision namespace glm { - /// Low precision 8 bit signed integer type. + /// Low qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 lowp_int8; - /// Low precision 16 bit signed integer type. + /// Low qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 lowp_int16; - /// Low precision 32 bit signed integer type. + /// Low qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 lowp_int32; - /// Low precision 64 bit signed integer type. + /// Low qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 lowp_int64; - /// Low precision 8 bit signed integer type. + /// Low qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 lowp_int8_t; - /// Low precision 16 bit signed integer type. + /// Low qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 lowp_int16_t; - /// Low precision 32 bit signed integer type. + /// Low qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 lowp_int32_t; - /// Low precision 64 bit signed integer type. + /// Low qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 lowp_int64_t; - /// Low precision 8 bit signed integer type. + /// Low qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 lowp_i8; - /// Low precision 16 bit signed integer type. + /// Low qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 lowp_i16; - /// Low precision 32 bit signed integer type. + /// Low qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 lowp_i32; - /// Low precision 64 bit signed integer type. + /// Low qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 lowp_i64; - /// Medium precision 8 bit signed integer type. + /// Medium qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 mediump_int8; - /// Medium precision 16 bit signed integer type. + /// Medium qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 mediump_int16; - /// Medium precision 32 bit signed integer type. + /// Medium qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 mediump_int32; - /// Medium precision 64 bit signed integer type. + /// Medium qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 mediump_int64; - /// Medium precision 8 bit signed integer type. + /// Medium qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 mediump_int8_t; - /// Medium precision 16 bit signed integer type. + /// Medium qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 mediump_int16_t; - /// Medium precision 32 bit signed integer type. + /// Medium qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 mediump_int32_t; - /// Medium precision 64 bit signed integer type. + /// Medium qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 mediump_int64_t; - /// Medium precision 8 bit signed integer type. + /// Medium qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 mediump_i8; - /// Medium precision 16 bit signed integer type. + /// Medium qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 mediump_i16; - /// Medium precision 32 bit signed integer type. + /// Medium qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 mediump_i32; - /// Medium precision 64 bit signed integer type. + /// Medium qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 mediump_i64; - /// High precision 8 bit signed integer type. + /// High qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 highp_int8; - /// High precision 16 bit signed integer type. + /// High qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 highp_int16; - /// High precision 32 bit signed integer type. + /// High qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 highp_int32; - /// High precision 64 bit signed integer type. + /// High qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 highp_int64; - /// High precision 8 bit signed integer type. + /// High qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 highp_int8_t; - /// High precision 16 bit signed integer type. + /// High qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 highp_int16_t; @@ -221,23 +221,23 @@ namespace glm /// @see gtc_type_precision typedef detail::int32 highp_int32_t; - /// High precision 64 bit signed integer type. + /// High qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 highp_int64_t; - /// High precision 8 bit signed integer type. + /// High qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 highp_i8; - /// High precision 16 bit signed integer type. + /// High qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 highp_i16; - /// High precision 32 bit signed integer type. + /// High qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 highp_i32; - /// High precision 64 bit signed integer type. + /// High qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 highp_i64; @@ -300,53 +300,53 @@ namespace glm - /// Low precision 8 bit signed integer scalar type. + /// Low qualifier 8 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i8, lowp> lowp_i8vec1; - /// Low precision 8 bit signed integer vector of 2 components type. + /// Low qualifier 8 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i8, lowp> lowp_i8vec2; - /// Low precision 8 bit signed integer vector of 3 components type. + /// Low qualifier 8 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i8, lowp> lowp_i8vec3; - /// Low precision 8 bit signed integer vector of 4 components type. + /// Low qualifier 8 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i8, lowp> lowp_i8vec4; - /// Medium precision 8 bit signed integer scalar type. + /// Medium qualifier 8 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i8, mediump> mediump_i8vec1; - /// Medium precision 8 bit signed integer vector of 2 components type. + /// Medium qualifier 8 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i8, mediump> mediump_i8vec2; - /// Medium precision 8 bit signed integer vector of 3 components type. + /// Medium qualifier 8 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i8, mediump> mediump_i8vec3; - /// Medium precision 8 bit signed integer vector of 4 components type. + /// Medium qualifier 8 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i8, mediump> mediump_i8vec4; - /// High precision 8 bit signed integer scalar type. + /// High qualifier 8 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i8, highp> highp_i8vec1; - /// High precision 8 bit signed integer vector of 2 components type. + /// High qualifier 8 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i8, highp> highp_i8vec2; - /// High precision 8 bit signed integer vector of 3 components type. + /// High qualifier 8 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i8, highp> highp_i8vec3; - /// High precision 8 bit signed integer vector of 4 components type. + /// High qualifier 8 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i8, highp> highp_i8vec4; @@ -361,71 +361,71 @@ namespace glm typedef mediump_i8vec3 i8vec3; typedef mediump_i8vec4 i8vec4; #else - /// Default precision 8 bit signed integer scalar type. + /// Default qualifier 8 bit signed integer scalar type. /// @see gtc_type_precision typedef highp_i8vec1 i8vec1; - /// Default precision 8 bit signed integer vector of 2 components type. + /// Default qualifier 8 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef highp_i8vec2 i8vec2; - /// Default precision 8 bit signed integer vector of 3 components type. + /// Default qualifier 8 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef highp_i8vec3 i8vec3; - /// Default precision 8 bit signed integer vector of 4 components type. + /// Default qualifier 8 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef highp_i8vec4 i8vec4; #endif - /// Low precision 16 bit signed integer scalar type. + /// Low qualifier 16 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i16, lowp> lowp_i16vec1; - /// Low precision 16 bit signed integer vector of 2 components type. + /// Low qualifier 16 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i16, lowp> lowp_i16vec2; - /// Low precision 16 bit signed integer vector of 3 components type. + /// Low qualifier 16 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i16, lowp> lowp_i16vec3; - /// Low precision 16 bit signed integer vector of 4 components type. + /// Low qualifier 16 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i16, lowp> lowp_i16vec4; - /// Medium precision 16 bit signed integer scalar type. + /// Medium qualifier 16 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i16, mediump> mediump_i16vec1; - /// Medium precision 16 bit signed integer vector of 2 components type. + /// Medium qualifier 16 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i16, mediump> mediump_i16vec2; - /// Medium precision 16 bit signed integer vector of 3 components type. + /// Medium qualifier 16 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i16, mediump> mediump_i16vec3; - /// Medium precision 16 bit signed integer vector of 4 components type. + /// Medium qualifier 16 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i16, mediump> mediump_i16vec4; - /// High precision 16 bit signed integer scalar type. + /// High qualifier 16 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i16, highp> highp_i16vec1; - /// High precision 16 bit signed integer vector of 2 components type. + /// High qualifier 16 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i16, highp> highp_i16vec2; - /// High precision 16 bit signed integer vector of 3 components type. + /// High qualifier 16 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i16, highp> highp_i16vec3; - /// High precision 16 bit signed integer vector of 4 components type. + /// High qualifier 16 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i16, highp> highp_i16vec4; @@ -441,71 +441,71 @@ namespace glm typedef mediump_i16vec3 i16vec3; typedef mediump_i16vec4 i16vec4; #else - /// Default precision 16 bit signed integer scalar type. + /// Default qualifier 16 bit signed integer scalar type. /// @see gtc_type_precision typedef highp_i16vec1 i16vec1; - /// Default precision 16 bit signed integer vector of 2 components type. + /// Default qualifier 16 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef highp_i16vec2 i16vec2; - /// Default precision 16 bit signed integer vector of 3 components type. + /// Default qualifier 16 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef highp_i16vec3 i16vec3; - /// Default precision 16 bit signed integer vector of 4 components type. + /// Default qualifier 16 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef highp_i16vec4 i16vec4; #endif - /// Low precision 32 bit signed integer scalar type. + /// Low qualifier 32 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i32, lowp> lowp_i32vec1; - /// Low precision 32 bit signed integer vector of 2 components type. + /// Low qualifier 32 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i32, lowp> lowp_i32vec2; - /// Low precision 32 bit signed integer vector of 3 components type. + /// Low qualifier 32 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i32, lowp> lowp_i32vec3; - /// Low precision 32 bit signed integer vector of 4 components type. + /// Low qualifier 32 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i32, lowp> lowp_i32vec4; - /// Medium precision 32 bit signed integer scalar type. + /// Medium qualifier 32 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i32, mediump> mediump_i32vec1; - /// Medium precision 32 bit signed integer vector of 2 components type. + /// Medium qualifier 32 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i32, mediump> mediump_i32vec2; - /// Medium precision 32 bit signed integer vector of 3 components type. + /// Medium qualifier 32 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i32, mediump> mediump_i32vec3; - /// Medium precision 32 bit signed integer vector of 4 components type. + /// Medium qualifier 32 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i32, mediump> mediump_i32vec4; - /// High precision 32 bit signed integer scalar type. + /// High qualifier 32 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i32, highp> highp_i32vec1; - /// High precision 32 bit signed integer vector of 2 components type. + /// High qualifier 32 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i32, highp> highp_i32vec2; - /// High precision 32 bit signed integer vector of 3 components type. + /// High qualifier 32 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i32, highp> highp_i32vec3; - /// High precision 32 bit signed integer vector of 4 components type. + /// High qualifier 32 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i32, highp> highp_i32vec4; @@ -520,71 +520,71 @@ namespace glm typedef mediump_i32vec3 i32vec3; typedef mediump_i32vec4 i32vec4; #else - /// Default precision 32 bit signed integer scalar type. + /// Default qualifier 32 bit signed integer scalar type. /// @see gtc_type_precision typedef highp_i32vec1 i32vec1; - /// Default precision 32 bit signed integer vector of 2 components type. + /// Default qualifier 32 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef highp_i32vec2 i32vec2; - /// Default precision 32 bit signed integer vector of 3 components type. + /// Default qualifier 32 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef highp_i32vec3 i32vec3; - /// Default precision 32 bit signed integer vector of 4 components type. + /// Default qualifier 32 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef highp_i32vec4 i32vec4; #endif - /// Low precision 32 bit signed integer scalar type. + /// Low qualifier 32 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i32, lowp> lowp_i32vec1; - /// Low precision 32 bit signed integer vector of 2 components type. + /// Low qualifier 32 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i32, lowp> lowp_i32vec2; - /// Low precision 32 bit signed integer vector of 3 components type. + /// Low qualifier 32 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i32, lowp> lowp_i32vec3; - /// Low precision 32 bit signed integer vector of 4 components type. + /// Low qualifier 32 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i32, lowp> lowp_i32vec4; - /// Medium precision 32 bit signed integer scalar type. + /// Medium qualifier 32 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i32, mediump> mediump_i32vec1; - /// Medium precision 32 bit signed integer vector of 2 components type. + /// Medium qualifier 32 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i32, mediump> mediump_i32vec2; - /// Medium precision 32 bit signed integer vector of 3 components type. + /// Medium qualifier 32 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i32, mediump> mediump_i32vec3; - /// Medium precision 32 bit signed integer vector of 4 components type. + /// Medium qualifier 32 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i32, mediump> mediump_i32vec4; - /// High precision 32 bit signed integer scalar type. + /// High qualifier 32 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i32, highp> highp_i32vec1; - /// High precision 32 bit signed integer vector of 2 components type. + /// High qualifier 32 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i32, highp> highp_i32vec2; - /// High precision 32 bit signed integer vector of 3 components type. + /// High qualifier 32 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i32, highp> highp_i32vec3; - /// High precision 32 bit signed integer vector of 4 components type. + /// High qualifier 32 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i32, highp> highp_i32vec4; @@ -599,72 +599,72 @@ namespace glm typedef mediump_i32vec3 i32vec3; typedef mediump_i32vec4 i32vec4; #else - /// Default precision 32 bit signed integer scalar type. + /// Default qualifier 32 bit signed integer scalar type. /// @see gtc_type_precision typedef highp_i32vec1 i32vec1; - /// Default precision 32 bit signed integer vector of 2 components type. + /// Default qualifier 32 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef highp_i32vec2 i32vec2; - /// Default precision 32 bit signed integer vector of 3 components type. + /// Default qualifier 32 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef highp_i32vec3 i32vec3; - /// Default precision 32 bit signed integer vector of 4 components type. + /// Default qualifier 32 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef highp_i32vec4 i32vec4; #endif - /// Low precision 64 bit signed integer scalar type. + /// Low qualifier 64 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i64, lowp> lowp_i64vec1; - /// Low precision 64 bit signed integer vector of 2 components type. + /// Low qualifier 64 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i64, lowp> lowp_i64vec2; - /// Low precision 64 bit signed integer vector of 3 components type. + /// Low qualifier 64 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i64, lowp> lowp_i64vec3; - /// Low precision 64 bit signed integer vector of 4 components type. + /// Low qualifier 64 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i64, lowp> lowp_i64vec4; - /// Medium precision 64 bit signed integer scalar type. + /// Medium qualifier 64 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i64, mediump> mediump_i64vec1; - /// Medium precision 64 bit signed integer vector of 2 components type. + /// Medium qualifier 64 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i64, mediump> mediump_i64vec2; - /// Medium precision 64 bit signed integer vector of 3 components type. + /// Medium qualifier 64 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i64, mediump> mediump_i64vec3; - /// Medium precision 64 bit signed integer vector of 4 components type. + /// Medium qualifier 64 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i64, mediump> mediump_i64vec4; - /// High precision 64 bit signed integer scalar type. + /// High qualifier 64 bit signed integer scalar type. /// @see gtc_type_precision typedef vec<1, i64, highp> highp_i64vec1; - /// High precision 64 bit signed integer vector of 2 components type. + /// High qualifier 64 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, i64, highp> highp_i64vec2; - /// High precision 64 bit signed integer vector of 3 components type. + /// High qualifier 64 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, i64, highp> highp_i64vec3; - /// High precision 64 bit signed integer vector of 4 components type. + /// High qualifier 64 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, i64, highp> highp_i64vec4; @@ -679,19 +679,19 @@ namespace glm typedef mediump_i64vec3 i64vec3; typedef mediump_i64vec4 i64vec4; #else - /// Default precision 64 bit signed integer scalar type. + /// Default qualifier 64 bit signed integer scalar type. /// @see gtc_type_precision typedef highp_i64vec1 i64vec1; - /// Default precision 64 bit signed integer vector of 2 components type. + /// Default qualifier 64 bit signed integer vector of 2 components type. /// @see gtc_type_precision typedef highp_i64vec2 i64vec2; - /// Default precision 64 bit signed integer vector of 3 components type. + /// Default qualifier 64 bit signed integer vector of 3 components type. /// @see gtc_type_precision typedef highp_i64vec3 i64vec3; - /// Default precision 64 bit signed integer vector of 4 components type. + /// Default qualifier 64 bit signed integer vector of 4 components type. /// @see gtc_type_precision typedef highp_i64vec4 i64vec4; #endif @@ -700,153 +700,153 @@ namespace glm ///////////////////////////// // Unsigned int vector types - /// Low precision 8 bit unsigned integer type. + /// Low qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 lowp_uint8; - /// Low precision 16 bit unsigned integer type. + /// Low qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 lowp_uint16; - /// Low precision 32 bit unsigned integer type. + /// Low qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 lowp_uint32; - /// Low precision 64 bit unsigned integer type. + /// Low qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 lowp_uint64; - /// Low precision 8 bit unsigned integer type. + /// Low qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 lowp_uint8_t; - /// Low precision 16 bit unsigned integer type. + /// Low qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 lowp_uint16_t; - /// Low precision 32 bit unsigned integer type. + /// Low qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 lowp_uint32_t; - /// Low precision 64 bit unsigned integer type. + /// Low qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 lowp_uint64_t; - /// Low precision 8 bit unsigned integer type. + /// Low qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 lowp_u8; - /// Low precision 16 bit unsigned integer type. + /// Low qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 lowp_u16; - /// Low precision 32 bit unsigned integer type. + /// Low qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 lowp_u32; - /// Low precision 64 bit unsigned integer type. + /// Low qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 lowp_u64; - /// Medium precision 8 bit unsigned integer type. + /// Medium qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 mediump_uint8; - /// Medium precision 16 bit unsigned integer type. + /// Medium qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 mediump_uint16; - /// Medium precision 32 bit unsigned integer type. + /// Medium qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 mediump_uint32; - /// Medium precision 64 bit unsigned integer type. + /// Medium qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 mediump_uint64; - /// Medium precision 8 bit unsigned integer type. + /// Medium qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 mediump_uint8_t; - /// Medium precision 16 bit unsigned integer type. + /// Medium qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 mediump_uint16_t; - /// Medium precision 32 bit unsigned integer type. + /// Medium qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 mediump_uint32_t; - /// Medium precision 64 bit unsigned integer type. + /// Medium qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 mediump_uint64_t; - /// Medium precision 8 bit unsigned integer type. + /// Medium qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 mediump_u8; - /// Medium precision 16 bit unsigned integer type. + /// Medium qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 mediump_u16; - /// Medium precision 32 bit unsigned integer type. + /// Medium qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 mediump_u32; - /// Medium precision 64 bit unsigned integer type. + /// Medium qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 mediump_u64; - /// Medium precision 8 bit unsigned integer type. + /// Medium qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 highp_uint8; - /// Medium precision 16 bit unsigned integer type. + /// Medium qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 highp_uint16; - /// Medium precision 32 bit unsigned integer type. + /// Medium qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 highp_uint32; - /// Medium precision 64 bit unsigned integer type. + /// Medium qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 highp_uint64; - /// Medium precision 8 bit unsigned integer type. + /// Medium qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 highp_uint8_t; - /// Medium precision 16 bit unsigned integer type. + /// Medium qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 highp_uint16_t; - /// Medium precision 32 bit unsigned integer type. + /// Medium qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 highp_uint32_t; - /// Medium precision 64 bit unsigned integer type. + /// Medium qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 highp_uint64_t; - /// Medium precision 8 bit unsigned integer type. + /// Medium qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 highp_u8; - /// Medium precision 16 bit unsigned integer type. + /// Medium qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 highp_u16; - /// Medium precision 32 bit unsigned integer type. + /// Medium qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 highp_u32; - /// Medium precision 64 bit unsigned integer type. + /// Medium qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 highp_u64; @@ -909,53 +909,53 @@ namespace glm - /// Low precision 8 bit unsigned integer scalar type. + /// Low qualifier 8 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u8, lowp> lowp_u8vec1; - /// Low precision 8 bit unsigned integer vector of 2 components type. + /// Low qualifier 8 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u8, lowp> lowp_u8vec2; - /// Low precision 8 bit unsigned integer vector of 3 components type. + /// Low qualifier 8 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u8, lowp> lowp_u8vec3; - /// Low precision 8 bit unsigned integer vector of 4 components type. + /// Low qualifier 8 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u8, lowp> lowp_u8vec4; - /// Medium precision 8 bit unsigned integer scalar type. + /// Medium qualifier 8 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u8, mediump> mediump_u8vec1; - /// Medium precision 8 bit unsigned integer vector of 2 components type. + /// Medium qualifier 8 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u8, mediump> mediump_u8vec2; - /// Medium precision 8 bit unsigned integer vector of 3 components type. + /// Medium qualifier 8 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u8, mediump> mediump_u8vec3; - /// Medium precision 8 bit unsigned integer vector of 4 components type. + /// Medium qualifier 8 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u8, mediump> mediump_u8vec4; - /// High precision 8 bit unsigned integer scalar type. + /// High qualifier 8 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u8, highp> highp_u8vec1; - /// High precision 8 bit unsigned integer vector of 2 components type. + /// High qualifier 8 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u8, highp> highp_u8vec2; - /// High precision 8 bit unsigned integer vector of 3 components type. + /// High qualifier 8 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u8, highp> highp_u8vec3; - /// High precision 8 bit unsigned integer vector of 4 components type. + /// High qualifier 8 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u8, highp> highp_u8vec4; @@ -970,71 +970,71 @@ namespace glm typedef mediump_u8vec3 u8vec3; typedef mediump_u8vec4 u8vec4; #else - /// Default precision 8 bit unsigned integer scalar type. + /// Default qualifier 8 bit unsigned integer scalar type. /// @see gtc_type_precision typedef highp_u8vec1 u8vec1; - /// Default precision 8 bit unsigned integer vector of 2 components type. + /// Default qualifier 8 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef highp_u8vec2 u8vec2; - /// Default precision 8 bit unsigned integer vector of 3 components type. + /// Default qualifier 8 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef highp_u8vec3 u8vec3; - /// Default precision 8 bit unsigned integer vector of 4 components type. + /// Default qualifier 8 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef highp_u8vec4 u8vec4; #endif - /// Low precision 16 bit unsigned integer scalar type. + /// Low qualifier 16 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u16, lowp> lowp_u16vec1; - /// Low precision 16 bit unsigned integer vector of 2 components type. + /// Low qualifier 16 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u16, lowp> lowp_u16vec2; - /// Low precision 16 bit unsigned integer vector of 3 components type. + /// Low qualifier 16 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u16, lowp> lowp_u16vec3; - /// Low precision 16 bit unsigned integer vector of 4 components type. + /// Low qualifier 16 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u16, lowp> lowp_u16vec4; - /// Medium precision 16 bit unsigned integer scalar type. + /// Medium qualifier 16 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u16, mediump> mediump_u16vec1; - /// Medium precision 16 bit unsigned integer vector of 2 components type. + /// Medium qualifier 16 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u16, mediump> mediump_u16vec2; - /// Medium precision 16 bit unsigned integer vector of 3 components type. + /// Medium qualifier 16 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u16, mediump> mediump_u16vec3; - /// Medium precision 16 bit unsigned integer vector of 4 components type. + /// Medium qualifier 16 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u16, mediump> mediump_u16vec4; - /// High precision 16 bit unsigned integer scalar type. + /// High qualifier 16 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u16, highp> highp_u16vec1; - /// High precision 16 bit unsigned integer vector of 2 components type. + /// High qualifier 16 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u16, highp> highp_u16vec2; - /// High precision 16 bit unsigned integer vector of 3 components type. + /// High qualifier 16 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u16, highp> highp_u16vec3; - /// High precision 16 bit unsigned integer vector of 4 components type. + /// High qualifier 16 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u16, highp> highp_u16vec4; @@ -1050,71 +1050,71 @@ namespace glm typedef mediump_u16vec3 u16vec3; typedef mediump_u16vec4 u16vec4; #else - /// Default precision 16 bit unsigned integer scalar type. + /// Default qualifier 16 bit unsigned integer scalar type. /// @see gtc_type_precision typedef highp_u16vec1 u16vec1; - /// Default precision 16 bit unsigned integer vector of 2 components type. + /// Default qualifier 16 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef highp_u16vec2 u16vec2; - /// Default precision 16 bit unsigned integer vector of 3 components type. + /// Default qualifier 16 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef highp_u16vec3 u16vec3; - /// Default precision 16 bit unsigned integer vector of 4 components type. + /// Default qualifier 16 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef highp_u16vec4 u16vec4; #endif - /// Low precision 32 bit unsigned integer scalar type. + /// Low qualifier 32 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u32, lowp> lowp_u32vec1; - /// Low precision 32 bit unsigned integer vector of 2 components type. + /// Low qualifier 32 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u32, lowp> lowp_u32vec2; - /// Low precision 32 bit unsigned integer vector of 3 components type. + /// Low qualifier 32 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u32, lowp> lowp_u32vec3; - /// Low precision 32 bit unsigned integer vector of 4 components type. + /// Low qualifier 32 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u32, lowp> lowp_u32vec4; - /// Medium precision 32 bit unsigned integer scalar type. + /// Medium qualifier 32 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u32, mediump> mediump_u32vec1; - /// Medium precision 32 bit unsigned integer vector of 2 components type. + /// Medium qualifier 32 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u32, mediump> mediump_u32vec2; - /// Medium precision 32 bit unsigned integer vector of 3 components type. + /// Medium qualifier 32 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u32, mediump> mediump_u32vec3; - /// Medium precision 32 bit unsigned integer vector of 4 components type. + /// Medium qualifier 32 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u32, mediump> mediump_u32vec4; - /// High precision 32 bit unsigned integer scalar type. + /// High qualifier 32 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u32, highp> highp_u32vec1; - /// High precision 32 bit unsigned integer vector of 2 components type. + /// High qualifier 32 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u32, highp> highp_u32vec2; - /// High precision 32 bit unsigned integer vector of 3 components type. + /// High qualifier 32 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u32, highp> highp_u32vec3; - /// High precision 32 bit unsigned integer vector of 4 components type. + /// High qualifier 32 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u32, highp> highp_u32vec4; @@ -1129,71 +1129,71 @@ namespace glm typedef mediump_u32vec3 u32vec3; typedef mediump_u32vec4 u32vec4; #else - /// Default precision 32 bit unsigned integer scalar type. + /// Default qualifier 32 bit unsigned integer scalar type. /// @see gtc_type_precision typedef highp_u32vec1 u32vec1; - /// Default precision 32 bit unsigned integer vector of 2 components type. + /// Default qualifier 32 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef highp_u32vec2 u32vec2; - /// Default precision 32 bit unsigned integer vector of 3 components type. + /// Default qualifier 32 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef highp_u32vec3 u32vec3; - /// Default precision 32 bit unsigned integer vector of 4 components type. + /// Default qualifier 32 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef highp_u32vec4 u32vec4; #endif - /// Low precision 32 bit unsigned integer scalar type. + /// Low qualifier 32 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u32, lowp> lowp_u32vec1; - /// Low precision 32 bit unsigned integer vector of 2 components type. + /// Low qualifier 32 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u32, lowp> lowp_u32vec2; - /// Low precision 32 bit unsigned integer vector of 3 components type. + /// Low qualifier 32 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u32, lowp> lowp_u32vec3; - /// Low precision 32 bit unsigned integer vector of 4 components type. + /// Low qualifier 32 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u32, lowp> lowp_u32vec4; - /// Medium precision 32 bit unsigned integer scalar type. + /// Medium qualifier 32 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u32, mediump> mediump_u32vec1; - /// Medium precision 32 bit unsigned integer vector of 2 components type. + /// Medium qualifier 32 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u32, mediump> mediump_u32vec2; - /// Medium precision 32 bit unsigned integer vector of 3 components type. + /// Medium qualifier 32 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u32, mediump> mediump_u32vec3; - /// Medium precision 32 bit unsigned integer vector of 4 components type. + /// Medium qualifier 32 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u32, mediump> mediump_u32vec4; - /// High precision 32 bit unsigned integer scalar type. + /// High qualifier 32 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u32, highp> highp_u32vec1; - /// High precision 32 bit unsigned integer vector of 2 components type. + /// High qualifier 32 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u32, highp> highp_u32vec2; - /// High precision 32 bit unsigned integer vector of 3 components type. + /// High qualifier 32 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u32, highp> highp_u32vec3; - /// High precision 32 bit unsigned integer vector of 4 components type. + /// High qualifier 32 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u32, highp> highp_u32vec4; @@ -1208,72 +1208,72 @@ namespace glm typedef mediump_u32vec3 u32vec3; typedef mediump_u32vec4 u32vec4; #else - /// Default precision 32 bit unsigned integer scalar type. + /// Default qualifier 32 bit unsigned integer scalar type. /// @see gtc_type_precision typedef highp_u32vec1 u32vec1; - /// Default precision 32 bit unsigned integer vector of 2 components type. + /// Default qualifier 32 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef highp_u32vec2 u32vec2; - /// Default precision 32 bit unsigned integer vector of 3 components type. + /// Default qualifier 32 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef highp_u32vec3 u32vec3; - /// Default precision 32 bit unsigned integer vector of 4 components type. + /// Default qualifier 32 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef highp_u32vec4 u32vec4; #endif - /// Low precision 64 bit unsigned integer scalar type. + /// Low qualifier 64 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u64, lowp> lowp_u64vec1; - /// Low precision 64 bit unsigned integer vector of 2 components type. + /// Low qualifier 64 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u64, lowp> lowp_u64vec2; - /// Low precision 64 bit unsigned integer vector of 3 components type. + /// Low qualifier 64 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u64, lowp> lowp_u64vec3; - /// Low precision 64 bit unsigned integer vector of 4 components type. + /// Low qualifier 64 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u64, lowp> lowp_u64vec4; - /// Medium precision 64 bit unsigned integer scalar type. + /// Medium qualifier 64 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u64, mediump> mediump_u64vec1; - /// Medium precision 64 bit unsigned integer vector of 2 components type. + /// Medium qualifier 64 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u64, mediump> mediump_u64vec2; - /// Medium precision 64 bit unsigned integer vector of 3 components type. + /// Medium qualifier 64 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u64, mediump> mediump_u64vec3; - /// Medium precision 64 bit unsigned integer vector of 4 components type. + /// Medium qualifier 64 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u64, mediump> mediump_u64vec4; - /// High precision 64 bit unsigned integer scalar type. + /// High qualifier 64 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u64, highp> highp_u64vec1; - /// High precision 64 bit unsigned integer vector of 2 components type. + /// High qualifier 64 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u64, highp> highp_u64vec2; - /// High precision 64 bit unsigned integer vector of 3 components type. + /// High qualifier 64 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u64, highp> highp_u64vec3; - /// High precision 64 bit unsigned integer vector of 4 components type. + /// High qualifier 64 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u64, highp> highp_u64vec4; @@ -1288,19 +1288,19 @@ namespace glm typedef mediump_u64vec3 u64vec3; typedef mediump_u64vec4 u64vec4; #else - /// Default precision 64 bit unsigned integer scalar type. + /// Default qualifier 64 bit unsigned integer scalar type. /// @see gtc_type_precision typedef highp_u64vec1 u64vec1; - /// Default precision 64 bit unsigned integer vector of 2 components type. + /// Default qualifier 64 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef highp_u64vec2 u64vec2; - /// Default precision 64 bit unsigned integer vector of 3 components type. + /// Default qualifier 64 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef highp_u64vec3 u64vec3; - /// Default precision 64 bit unsigned integer vector of 4 components type. + /// Default qualifier 64 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef highp_u64vec4 u64vec4; #endif @@ -1309,402 +1309,402 @@ namespace glm ////////////////////// // Float vector types - /// Low 32 bit single-precision floating-point scalar. + /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 lowp_float32; - /// Low 64 bit double-precision floating-point scalar. + /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 lowp_float64; - /// Low 32 bit single-precision floating-point scalar. + /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 lowp_float32_t; - /// Low 64 bit double-precision floating-point scalar. + /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 lowp_float64_t; - /// Low 32 bit single-precision floating-point scalar. + /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 lowp_f32; - /// Low 64 bit double-precision floating-point scalar. + /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 lowp_f64; - /// Low 32 bit single-precision floating-point scalar. + /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 lowp_float32; - /// Low 64 bit double-precision floating-point scalar. + /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 lowp_float64; - /// Low 32 bit single-precision floating-point scalar. + /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 lowp_float32_t; - /// Low 64 bit double-precision floating-point scalar. + /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 lowp_float64_t; - /// Low 32 bit single-precision floating-point scalar. + /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 lowp_f32; - /// Low 64 bit double-precision floating-point scalar. + /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 lowp_f64; - /// Low 32 bit single-precision floating-point scalar. + /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 lowp_float32; - /// Low 64 bit double-precision floating-point scalar. + /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 lowp_float64; - /// Low 32 bit single-precision floating-point scalar. + /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 lowp_float32_t; - /// Low 64 bit double-precision floating-point scalar. + /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 lowp_float64_t; - /// Low 32 bit single-precision floating-point scalar. + /// Low 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 lowp_f32; - /// Low 64 bit double-precision floating-point scalar. + /// Low 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 lowp_f64; - /// Medium 32 bit single-precision floating-point scalar. + /// Medium 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 mediump_float32; - /// Medium 64 bit double-precision floating-point scalar. + /// Medium 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 mediump_float64; - /// Medium 32 bit single-precision floating-point scalar. + /// Medium 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 mediump_float32_t; - /// Medium 64 bit double-precision floating-point scalar. + /// Medium 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 mediump_float64_t; - /// Medium 32 bit single-precision floating-point scalar. + /// Medium 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 mediump_f32; - /// Medium 64 bit double-precision floating-point scalar. + /// Medium 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 mediump_f64; - /// High 32 bit single-precision floating-point scalar. + /// High 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 highp_float32; - /// High 64 bit double-precision floating-point scalar. + /// High 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 highp_float64; - /// High 32 bit single-precision floating-point scalar. + /// High 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 highp_float32_t; - /// High 64 bit double-precision floating-point scalar. + /// High 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 highp_float64_t; - /// High 32 bit single-precision floating-point scalar. + /// High 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 highp_f32; - /// High 64 bit double-precision floating-point scalar. + /// High 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 highp_f64; #if(defined(GLM_PRECISION_LOWP_FLOAT)) - /// Default 32 bit single-precision floating-point scalar. + /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef lowp_float32 float32; - /// Default 64 bit double-precision floating-point scalar. + /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef lowp_float64 float64; - /// Default 32 bit single-precision floating-point scalar. + /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef lowp_float32_t float32_t; - /// Default 64 bit double-precision floating-point scalar. + /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef lowp_float64_t float64_t; - /// Default 32 bit single-precision floating-point scalar. + /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef lowp_f32 f32; - /// Default 64 bit double-precision floating-point scalar. + /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef lowp_f64 f64; #elif(defined(GLM_PRECISION_MEDIUMP_FLOAT)) - /// Default 32 bit single-precision floating-point scalar. + /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef mediump_float32 float32; - /// Default 64 bit double-precision floating-point scalar. + /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef mediump_float64 float64; - /// Default 32 bit single-precision floating-point scalar. + /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef mediump_float32 float32_t; - /// Default 64 bit double-precision floating-point scalar. + /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef mediump_float64 float64_t; - /// Default 32 bit single-precision floating-point scalar. + /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef mediump_float32 f32; - /// Default 64 bit double-precision floating-point scalar. + /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef mediump_float64 f64; #else//(defined(GLM_PRECISION_HIGHP_FLOAT)) - /// Default 32 bit single-precision floating-point scalar. + /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef highp_float32 float32; - /// Default 64 bit double-precision floating-point scalar. + /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef highp_float64 float64; - /// Default 32 bit single-precision floating-point scalar. + /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef highp_float32_t float32_t; - /// Default 64 bit double-precision floating-point scalar. + /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef highp_float64_t float64_t; - /// Default 32 bit single-precision floating-point scalar. + /// Default 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef highp_float32_t f32; - /// Default 64 bit double-precision floating-point scalar. + /// Default 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef highp_float64_t f64; #endif - /// Low single-precision floating-point vector of 1 component. + /// Low single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, float, lowp> lowp_vec1; - /// Low single-precision floating-point vector of 2 components. + /// Low single-qualifier floating-point vector of 2 components. /// @see core_precision typedef vec<2, float, lowp> lowp_vec2; - /// Low single-precision floating-point vector of 3 components. + /// Low single-qualifier floating-point vector of 3 components. /// @see core_precision typedef vec<3, float, lowp> lowp_vec3; - /// Low single-precision floating-point vector of 4 components. + /// Low single-qualifier floating-point vector of 4 components. /// @see core_precision typedef vec<4, float, lowp> lowp_vec4; - /// Low single-precision floating-point vector of 1 component. + /// Low single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, float, lowp> lowp_fvec1; - /// Low single-precision floating-point vector of 2 components. + /// Low single-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, float, lowp> lowp_fvec2; - /// Low single-precision floating-point vector of 3 components. + /// Low single-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, float, lowp> lowp_fvec3; - /// Low single-precision floating-point vector of 4 components. + /// Low single-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, float, lowp> lowp_fvec4; - /// Medium single-precision floating-point vector of 1 component. + /// Medium single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, float, mediump> mediump_vec1; - /// Medium Single-precision floating-point vector of 2 components. + /// Medium Single-qualifier floating-point vector of 2 components. /// @see core_precision typedef vec<2, float, mediump> mediump_vec2; - /// Medium Single-precision floating-point vector of 3 components. + /// Medium Single-qualifier floating-point vector of 3 components. /// @see core_precision typedef vec<3, float, mediump> mediump_vec3; - /// Medium Single-precision floating-point vector of 4 components. + /// Medium Single-qualifier floating-point vector of 4 components. /// @see core_precision typedef vec<4, float, mediump> mediump_vec4; - /// Medium single-precision floating-point vector of 1 component. + /// Medium single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, float, mediump> mediump_fvec1; - /// Medium Single-precision floating-point vector of 2 components. + /// Medium Single-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, float, mediump> mediump_fvec2; - /// Medium Single-precision floating-point vector of 3 components. + /// Medium Single-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, float, mediump> mediump_fvec3; - /// Medium Single-precision floating-point vector of 4 components. + /// Medium Single-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, float, mediump> mediump_fvec4; - /// High single-precision floating-point vector of 1 component. + /// High single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, float, highp> highp_vec1; - /// High Single-precision floating-point vector of 2 components. + /// High Single-qualifier floating-point vector of 2 components. /// @see core_precision typedef vec<2, float, highp> highp_vec2; - /// High Single-precision floating-point vector of 3 components. + /// High Single-qualifier floating-point vector of 3 components. /// @see core_precision typedef vec<3, float, highp> highp_vec3; - /// High Single-precision floating-point vector of 4 components. + /// High Single-qualifier floating-point vector of 4 components. /// @see core_precision typedef vec<4, float, highp> highp_vec4; - /// High single-precision floating-point vector of 1 component. + /// High single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, float, highp> highp_fvec1; - /// High Single-precision floating-point vector of 2 components. + /// High Single-qualifier floating-point vector of 2 components. /// @see core_precision typedef vec<2, float, highp> highp_fvec2; - /// High Single-precision floating-point vector of 3 components. + /// High Single-qualifier floating-point vector of 3 components. /// @see core_precision typedef vec<3, float, highp> highp_fvec3; - /// High Single-precision floating-point vector of 4 components. + /// High Single-qualifier floating-point vector of 4 components. /// @see core_precision typedef vec<4, float, highp> highp_fvec4; - /// Low single-precision floating-point vector of 1 component. + /// Low single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f32, lowp> lowp_f32vec1; - /// Low single-precision floating-point vector of 2 components. + /// Low single-qualifier floating-point vector of 2 components. /// @see core_precision typedef vec<2, f32, lowp> lowp_f32vec2; - /// Low single-precision floating-point vector of 3 components. + /// Low single-qualifier floating-point vector of 3 components. /// @see core_precision typedef vec<3, f32, lowp> lowp_f32vec3; - /// Low single-precision floating-point vector of 4 components. + /// Low single-qualifier floating-point vector of 4 components. /// @see core_precision typedef vec<4, f32, lowp> lowp_f32vec4; - /// Medium single-precision floating-point vector of 1 component. + /// Medium single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f32, mediump> mediump_f32vec1; - /// Medium single-precision floating-point vector of 2 components. + /// Medium single-qualifier floating-point vector of 2 components. /// @see core_precision typedef vec<2, f32, mediump> mediump_f32vec2; - /// Medium single-precision floating-point vector of 3 components. + /// Medium single-qualifier floating-point vector of 3 components. /// @see core_precision typedef vec<3, f32, mediump> mediump_f32vec3; - /// Medium single-precision floating-point vector of 4 components. + /// Medium single-qualifier floating-point vector of 4 components. /// @see core_precision typedef vec<4, f32, mediump> mediump_f32vec4; - /// High single-precision floating-point vector of 1 component. + /// High single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f32, highp> highp_f32vec1; - /// High single-precision floating-point vector of 2 components. + /// High single-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, f32, highp> highp_f32vec2; - /// High single-precision floating-point vector of 3 components. + /// High single-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, f32, highp> highp_f32vec3; - /// High single-precision floating-point vector of 4 components. + /// High single-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, f32, highp> highp_f32vec4; - /// Low double-precision floating-point vector of 1 component. + /// Low double-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f64, lowp> lowp_f64vec1; - /// Low double-precision floating-point vector of 2 components. + /// Low double-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, f64, lowp> lowp_f64vec2; - /// Low double-precision floating-point vector of 3 components. + /// Low double-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, f64, lowp> lowp_f64vec3; - /// Low double-precision floating-point vector of 4 components. + /// Low double-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, f64, lowp> lowp_f64vec4; - /// Medium double-precision floating-point vector of 1 component. + /// Medium double-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f64, mediump> mediump_f64vec1; - /// Medium double-precision floating-point vector of 2 components. + /// Medium double-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, f64, mediump> mediump_f64vec2; - /// Medium double-precision floating-point vector of 3 components. + /// Medium double-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, f64, mediump> mediump_f64vec3; - /// Medium double-precision floating-point vector of 4 components. + /// Medium double-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, f64, mediump> mediump_f64vec4; - /// High double-precision floating-point vector of 1 component. + /// High double-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f64, highp> highp_f64vec1; - /// High double-precision floating-point vector of 2 components. + /// High double-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, f64, highp> highp_f64vec2; - /// High double-precision floating-point vector of 3 components. + /// High double-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, f64, highp> highp_f64vec3; - /// High double-precision floating-point vector of 4 components. + /// High double-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, f64, highp> highp_f64vec4; @@ -1712,541 +1712,541 @@ namespace glm ////////////////////// // Float matrix types - /// Low single-precision floating-point 1x1 matrix. + /// Low single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef lowp_f32 lowp_fmat1x1; - /// Low single-precision floating-point 2x2 matrix. + /// Low single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, lowp> lowp_fmat2x2; - /// Low single-precision floating-point 2x3 matrix. + /// Low single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, lowp> lowp_fmat2x3; - /// Low single-precision floating-point 2x4 matrix. + /// Low single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, lowp> lowp_fmat2x4; - /// Low single-precision floating-point 3x2 matrix. + /// Low single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, lowp> lowp_fmat3x2; - /// Low single-precision floating-point 3x3 matrix. + /// Low single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, lowp> lowp_fmat3x3; - /// Low single-precision floating-point 3x4 matrix. + /// Low single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, lowp> lowp_fmat3x4; - /// Low single-precision floating-point 4x2 matrix. + /// Low single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, lowp> lowp_fmat4x2; - /// Low single-precision floating-point 4x3 matrix. + /// Low single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, lowp> lowp_fmat4x3; - /// Low single-precision floating-point 4x4 matrix. + /// Low single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, lowp> lowp_fmat4x4; - /// Low single-precision floating-point 1x1 matrix. + /// Low single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef lowp_fmat1x1 lowp_fmat1; - /// Low single-precision floating-point 2x2 matrix. + /// Low single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef lowp_fmat2x2 lowp_fmat2; - /// Low single-precision floating-point 3x3 matrix. + /// Low single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef lowp_fmat3x3 lowp_fmat3; - /// Low single-precision floating-point 4x4 matrix. + /// Low single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef lowp_fmat4x4 lowp_fmat4; - /// Medium single-precision floating-point 1x1 matrix. + /// Medium single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef mediump_f32 mediump_fmat1x1; - /// Medium single-precision floating-point 2x2 matrix. + /// Medium single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, mediump> mediump_fmat2x2; - /// Medium single-precision floating-point 2x3 matrix. + /// Medium single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, mediump> mediump_fmat2x3; - /// Medium single-precision floating-point 2x4 matrix. + /// Medium single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, mediump> mediump_fmat2x4; - /// Medium single-precision floating-point 3x2 matrix. + /// Medium single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, mediump> mediump_fmat3x2; - /// Medium single-precision floating-point 3x3 matrix. + /// Medium single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, mediump> mediump_fmat3x3; - /// Medium single-precision floating-point 3x4 matrix. + /// Medium single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, mediump> mediump_fmat3x4; - /// Medium single-precision floating-point 4x2 matrix. + /// Medium single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, mediump> mediump_fmat4x2; - /// Medium single-precision floating-point 4x3 matrix. + /// Medium single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, mediump> mediump_fmat4x3; - /// Medium single-precision floating-point 4x4 matrix. + /// Medium single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, mediump> mediump_fmat4x4; - /// Medium single-precision floating-point 1x1 matrix. + /// Medium single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef mediump_fmat1x1 mediump_fmat1; - /// Medium single-precision floating-point 2x2 matrix. + /// Medium single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mediump_fmat2x2 mediump_fmat2; - /// Medium single-precision floating-point 3x3 matrix. + /// Medium single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mediump_fmat3x3 mediump_fmat3; - /// Medium single-precision floating-point 4x4 matrix. + /// Medium single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mediump_fmat4x4 mediump_fmat4; - /// High single-precision floating-point 1x1 matrix. + /// High single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef highp_f32 highp_fmat1x1; - /// High single-precision floating-point 2x2 matrix. + /// High single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, highp> highp_fmat2x2; - /// High single-precision floating-point 2x3 matrix. + /// High single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, highp> highp_fmat2x3; - /// High single-precision floating-point 2x4 matrix. + /// High single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, highp> highp_fmat2x4; - /// High single-precision floating-point 3x2 matrix. + /// High single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, highp> highp_fmat3x2; - /// High single-precision floating-point 3x3 matrix. + /// High single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, highp> highp_fmat3x3; - /// High single-precision floating-point 3x4 matrix. + /// High single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, highp> highp_fmat3x4; - /// High single-precision floating-point 4x2 matrix. + /// High single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, highp> highp_fmat4x2; - /// High single-precision floating-point 4x3 matrix. + /// High single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, highp> highp_fmat4x3; - /// High single-precision floating-point 4x4 matrix. + /// High single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, highp> highp_fmat4x4; - /// High single-precision floating-point 1x1 matrix. + /// High single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef highp_fmat1x1 highp_fmat1; - /// High single-precision floating-point 2x2 matrix. + /// High single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef highp_fmat2x2 highp_fmat2; - /// High single-precision floating-point 3x3 matrix. + /// High single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef highp_fmat3x3 highp_fmat3; - /// High single-precision floating-point 4x4 matrix. + /// High single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef highp_fmat4x4 highp_fmat4; - /// Low single-precision floating-point 1x1 matrix. + /// Low single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f32 lowp_f32mat1x1; - /// Low single-precision floating-point 2x2 matrix. + /// Low single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, lowp> lowp_f32mat2x2; - /// Low single-precision floating-point 2x3 matrix. + /// Low single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, lowp> lowp_f32mat2x3; - /// Low single-precision floating-point 2x4 matrix. + /// Low single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, lowp> lowp_f32mat2x4; - /// Low single-precision floating-point 3x2 matrix. + /// Low single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, lowp> lowp_f32mat3x2; - /// Low single-precision floating-point 3x3 matrix. + /// Low single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, lowp> lowp_f32mat3x3; - /// Low single-precision floating-point 3x4 matrix. + /// Low single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, lowp> lowp_f32mat3x4; - /// Low single-precision floating-point 4x2 matrix. + /// Low single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, lowp> lowp_f32mat4x2; - /// Low single-precision floating-point 4x3 matrix. + /// Low single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, lowp> lowp_f32mat4x3; - /// Low single-precision floating-point 4x4 matrix. + /// Low single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, lowp> lowp_f32mat4x4; - /// Low single-precision floating-point 1x1 matrix. + /// Low single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef detail::tmat1x1 lowp_f32mat1; - /// Low single-precision floating-point 2x2 matrix. + /// Low single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef lowp_f32mat2x2 lowp_f32mat2; - /// Low single-precision floating-point 3x3 matrix. + /// Low single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef lowp_f32mat3x3 lowp_f32mat3; - /// Low single-precision floating-point 4x4 matrix. + /// Low single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef lowp_f32mat4x4 lowp_f32mat4; - /// High single-precision floating-point 1x1 matrix. + /// High single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f32 mediump_f32mat1x1; - /// Low single-precision floating-point 2x2 matrix. + /// Low single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, mediump> mediump_f32mat2x2; - /// Medium single-precision floating-point 2x3 matrix. + /// Medium single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, mediump> mediump_f32mat2x3; - /// Medium single-precision floating-point 2x4 matrix. + /// Medium single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, mediump> mediump_f32mat2x4; - /// Medium single-precision floating-point 3x2 matrix. + /// Medium single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, mediump> mediump_f32mat3x2; - /// Medium single-precision floating-point 3x3 matrix. + /// Medium single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, mediump> mediump_f32mat3x3; - /// Medium single-precision floating-point 3x4 matrix. + /// Medium single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, mediump> mediump_f32mat3x4; - /// Medium single-precision floating-point 4x2 matrix. + /// Medium single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, mediump> mediump_f32mat4x2; - /// Medium single-precision floating-point 4x3 matrix. + /// Medium single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, mediump> mediump_f32mat4x3; - /// Medium single-precision floating-point 4x4 matrix. + /// Medium single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, mediump> mediump_f32mat4x4; - /// Medium single-precision floating-point 1x1 matrix. + /// Medium single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef detail::tmat1x1 f32mat1; - /// Medium single-precision floating-point 2x2 matrix. + /// Medium single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mediump_f32mat2x2 mediump_f32mat2; - /// Medium single-precision floating-point 3x3 matrix. + /// Medium single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mediump_f32mat3x3 mediump_f32mat3; - /// Medium single-precision floating-point 4x4 matrix. + /// Medium single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mediump_f32mat4x4 mediump_f32mat4; - /// High single-precision floating-point 1x1 matrix. + /// High single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f32 highp_f32mat1x1; - /// High single-precision floating-point 2x2 matrix. + /// High single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, highp> highp_f32mat2x2; - /// High single-precision floating-point 2x3 matrix. + /// High single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, highp> highp_f32mat2x3; - /// High single-precision floating-point 2x4 matrix. + /// High single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, highp> highp_f32mat2x4; - /// High single-precision floating-point 3x2 matrix. + /// High single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, highp> highp_f32mat3x2; - /// High single-precision floating-point 3x3 matrix. + /// High single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, highp> highp_f32mat3x3; - /// High single-precision floating-point 3x4 matrix. + /// High single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, highp> highp_f32mat3x4; - /// High single-precision floating-point 4x2 matrix. + /// High single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, highp> highp_f32mat4x2; - /// High single-precision floating-point 4x3 matrix. + /// High single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, highp> highp_f32mat4x3; - /// High single-precision floating-point 4x4 matrix. + /// High single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, highp> highp_f32mat4x4; - /// High single-precision floating-point 1x1 matrix. + /// High single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef detail::tmat1x1 f32mat1; - /// High single-precision floating-point 2x2 matrix. + /// High single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef highp_f32mat2x2 highp_f32mat2; - /// High single-precision floating-point 3x3 matrix. + /// High single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef highp_f32mat3x3 highp_f32mat3; - /// High single-precision floating-point 4x4 matrix. + /// High single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef highp_f32mat4x4 highp_f32mat4; - /// Low double-precision floating-point 1x1 matrix. + /// Low double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f64 lowp_f64mat1x1; - /// Low double-precision floating-point 2x2 matrix. + /// Low double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f64, lowp> lowp_f64mat2x2; - /// Low double-precision floating-point 2x3 matrix. + /// Low double-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f64, lowp> lowp_f64mat2x3; - /// Low double-precision floating-point 2x4 matrix. + /// Low double-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f64, lowp> lowp_f64mat2x4; - /// Low double-precision floating-point 3x2 matrix. + /// Low double-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f64, lowp> lowp_f64mat3x2; - /// Low double-precision floating-point 3x3 matrix. + /// Low double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f64, lowp> lowp_f64mat3x3; - /// Low double-precision floating-point 3x4 matrix. + /// Low double-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f64, lowp> lowp_f64mat3x4; - /// Low double-precision floating-point 4x2 matrix. + /// Low double-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f64, lowp> lowp_f64mat4x2; - /// Low double-precision floating-point 4x3 matrix. + /// Low double-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f64, lowp> lowp_f64mat4x3; - /// Low double-precision floating-point 4x4 matrix. + /// Low double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f64, lowp> lowp_f64mat4x4; - /// Low double-precision floating-point 1x1 matrix. + /// Low double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef lowp_f64mat1x1 lowp_f64mat1; - /// Low double-precision floating-point 2x2 matrix. + /// Low double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef lowp_f64mat2x2 lowp_f64mat2; - /// Low double-precision floating-point 3x3 matrix. + /// Low double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef lowp_f64mat3x3 lowp_f64mat3; - /// Low double-precision floating-point 4x4 matrix. + /// Low double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef lowp_f64mat4x4 lowp_f64mat4; - /// Medium double-precision floating-point 1x1 matrix. + /// Medium double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f64 Highp_f64mat1x1; - /// Medium double-precision floating-point 2x2 matrix. + /// Medium double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f64, mediump> mediump_f64mat2x2; - /// Medium double-precision floating-point 2x3 matrix. + /// Medium double-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f64, mediump> mediump_f64mat2x3; - /// Medium double-precision floating-point 2x4 matrix. + /// Medium double-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f64, mediump> mediump_f64mat2x4; - /// Medium double-precision floating-point 3x2 matrix. + /// Medium double-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f64, mediump> mediump_f64mat3x2; - /// Medium double-precision floating-point 3x3 matrix. + /// Medium double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f64, mediump> mediump_f64mat3x3; - /// Medium double-precision floating-point 3x4 matrix. + /// Medium double-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f64, mediump> mediump_f64mat3x4; - /// Medium double-precision floating-point 4x2 matrix. + /// Medium double-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f64, mediump> mediump_f64mat4x2; - /// Medium double-precision floating-point 4x3 matrix. + /// Medium double-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f64, mediump> mediump_f64mat4x3; - /// Medium double-precision floating-point 4x4 matrix. + /// Medium double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f64, mediump> mediump_f64mat4x4; - /// Medium double-precision floating-point 1x1 matrix. + /// Medium double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef mediump_f64mat1x1 mediump_f64mat1; - /// Medium double-precision floating-point 2x2 matrix. + /// Medium double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mediump_f64mat2x2 mediump_f64mat2; - /// Medium double-precision floating-point 3x3 matrix. + /// Medium double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mediump_f64mat3x3 mediump_f64mat3; - /// Medium double-precision floating-point 4x4 matrix. + /// Medium double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mediump_f64mat4x4 mediump_f64mat4; - /// High double-precision floating-point 1x1 matrix. + /// High double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f64 highp_f64mat1x1; - /// High double-precision floating-point 2x2 matrix. + /// High double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f64, highp> highp_f64mat2x2; - /// High double-precision floating-point 2x3 matrix. + /// High double-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f64, highp> highp_f64mat2x3; - /// High double-precision floating-point 2x4 matrix. + /// High double-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f64, highp> highp_f64mat2x4; - /// High double-precision floating-point 3x2 matrix. + /// High double-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f64, highp> highp_f64mat3x2; - /// High double-precision floating-point 3x3 matrix. + /// High double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f64, highp> highp_f64mat3x3; - /// High double-precision floating-point 3x4 matrix. + /// High double-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f64, highp> highp_f64mat3x4; - /// High double-precision floating-point 4x2 matrix. + /// High double-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f64, highp> highp_f64mat4x2; - /// High double-precision floating-point 4x3 matrix. + /// High double-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f64, highp> highp_f64mat4x3; - /// High double-precision floating-point 4x4 matrix. + /// High double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f64, highp> highp_f64mat4x4; - /// High double-precision floating-point 1x1 matrix. + /// High double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef highp_f64mat1x1 highp_f64mat1; - /// High double-precision floating-point 2x2 matrix. + /// High double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef highp_f64mat2x2 highp_f64mat2; - /// High double-precision floating-point 3x3 matrix. + /// High double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef highp_f64mat3x3 highp_f64mat3; - /// High double-precision floating-point 4x4 matrix. + /// High double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef highp_f64mat4x4 highp_f64mat4; ////////////////////////// // Quaternion types - /// Low single-precision floating-point quaternion. + /// Low single-qualifier floating-point quaternion. /// @see gtc_type_precision typedef tquat lowp_f32quat; - /// Low double-precision floating-point quaternion. + /// Low double-qualifier floating-point quaternion. /// @see gtc_type_precision typedef tquat lowp_f64quat; - /// Medium single-precision floating-point quaternion. + /// Medium single-qualifier floating-point quaternion. /// @see gtc_type_precision typedef tquat mediump_f32quat; - /// Medium double-precision floating-point quaternion. + /// Medium double-qualifier floating-point quaternion. /// @see gtc_type_precision typedef tquat mediump_f64quat; - /// High single-precision floating-point quaternion. + /// High single-qualifier floating-point quaternion. /// @see gtc_type_precision typedef tquat highp_f32quat; - /// High double-precision floating-point quaternion. + /// High double-qualifier floating-point quaternion. /// @see gtc_type_precision typedef tquat highp_f64quat; @@ -2324,141 +2324,141 @@ namespace glm typedef mediump_f32mat4x4 f32mat4x4; typedef mediump_f32quat f32quat; #else//if(defined(GLM_PRECISION_HIGHP_FLOAT)) - /// Default single-precision floating-point vector of 1 components. + /// Default single-qualifier floating-point vector of 1 components. /// @see gtc_type_precision typedef highp_f32vec1 fvec1; - /// Default single-precision floating-point vector of 2 components. + /// Default single-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef highp_f32vec2 fvec2; - /// Default single-precision floating-point vector of 3 components. + /// Default single-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef highp_f32vec3 fvec3; - /// Default single-precision floating-point vector of 4 components. + /// Default single-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef highp_f32vec4 fvec4; - /// Default single-precision floating-point 2x2 matrix. + /// Default single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef highp_f32mat2x2 fmat2x2; - /// Default single-precision floating-point 2x3 matrix. + /// Default single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef highp_f32mat2x3 fmat2x3; - /// Default single-precision floating-point 2x4 matrix. + /// Default single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef highp_f32mat2x4 fmat2x4; - /// Default single-precision floating-point 3x2 matrix. + /// Default single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef highp_f32mat3x2 fmat3x2; - /// Default single-precision floating-point 3x3 matrix. + /// Default single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef highp_f32mat3x3 fmat3x3; - /// Default single-precision floating-point 3x4 matrix. + /// Default single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef highp_f32mat3x4 fmat3x4; - /// Default single-precision floating-point 4x2 matrix. + /// Default single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef highp_f32mat4x2 fmat4x2; - /// Default single-precision floating-point 4x3 matrix. + /// Default single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef highp_f32mat4x3 fmat4x3; - /// Default single-precision floating-point 4x4 matrix. + /// Default single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef highp_f32mat4x4 fmat4x4; - /// Default single-precision floating-point 2x2 matrix. + /// Default single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef fmat2x2 fmat2; - /// Default single-precision floating-point 3x3 matrix. + /// Default single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef fmat3x3 fmat3; - /// Default single-precision floating-point 4x4 matrix. + /// Default single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef fmat4x4 fmat4; - /// Default single-precision floating-point quaternion. + /// Default single-qualifier floating-point quaternion. /// @see gtc_type_precision typedef highp_fquat fquat; - /// Default single-precision floating-point vector of 1 components. + /// Default single-qualifier floating-point vector of 1 components. /// @see gtc_type_precision typedef highp_f32vec1 f32vec1; - /// Default single-precision floating-point vector of 2 components. + /// Default single-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef highp_f32vec2 f32vec2; - /// Default single-precision floating-point vector of 3 components. + /// Default single-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef highp_f32vec3 f32vec3; - /// Default single-precision floating-point vector of 4 components. + /// Default single-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef highp_f32vec4 f32vec4; - /// Default single-precision floating-point 2x2 matrix. + /// Default single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef highp_f32mat2x2 f32mat2x2; - /// Default single-precision floating-point 2x3 matrix. + /// Default single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef highp_f32mat2x3 f32mat2x3; - /// Default single-precision floating-point 2x4 matrix. + /// Default single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef highp_f32mat2x4 f32mat2x4; - /// Default single-precision floating-point 3x2 matrix. + /// Default single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef highp_f32mat3x2 f32mat3x2; - /// Default single-precision floating-point 3x3 matrix. + /// Default single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef highp_f32mat3x3 f32mat3x3; - /// Default single-precision floating-point 3x4 matrix. + /// Default single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef highp_f32mat3x4 f32mat3x4; - /// Default single-precision floating-point 4x2 matrix. + /// Default single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef highp_f32mat4x2 f32mat4x2; - /// Default single-precision floating-point 4x3 matrix. + /// Default single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef highp_f32mat4x3 f32mat4x3; - /// Default single-precision floating-point 4x4 matrix. + /// Default single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef highp_f32mat4x4 f32mat4x4; - /// Default single-precision floating-point 2x2 matrix. + /// Default single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef f32mat2x2 f32mat2; - /// Default single-precision floating-point 3x3 matrix. + /// Default single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef f32mat3x3 f32mat3; - /// Default single-precision floating-point 4x4 matrix. + /// Default single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef f32mat4x4 f32mat4; - /// Default single-precision floating-point quaternion. + /// Default single-qualifier floating-point quaternion. /// @see gtc_type_precision typedef highp_f32quat f32quat; #endif @@ -2500,71 +2500,71 @@ namespace glm typedef mediump_f64mat4x4 f64mat4x4; typedef mediump_f64quat f64quat; #else - /// Default double-precision floating-point vector of 1 components. + /// Default double-qualifier floating-point vector of 1 components. /// @see gtc_type_precision typedef highp_f64vec1 f64vec1; - /// Default double-precision floating-point vector of 2 components. + /// Default double-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef highp_f64vec2 f64vec2; - /// Default double-precision floating-point vector of 3 components. + /// Default double-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef highp_f64vec3 f64vec3; - /// Default double-precision floating-point vector of 4 components. + /// Default double-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef highp_f64vec4 f64vec4; - /// Default double-precision floating-point 2x2 matrix. + /// Default double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef highp_f64mat2x2 f64mat2x2; - /// Default double-precision floating-point 2x3 matrix. + /// Default double-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef highp_f64mat2x3 f64mat2x3; - /// Default double-precision floating-point 2x4 matrix. + /// Default double-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef highp_f64mat2x4 f64mat2x4; - /// Default double-precision floating-point 3x2 matrix. + /// Default double-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef highp_f64mat3x2 f64mat3x2; - /// Default double-precision floating-point 3x3 matrix. + /// Default double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef highp_f64mat3x3 f64mat3x3; - /// Default double-precision floating-point 3x4 matrix. + /// Default double-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef highp_f64mat3x4 f64mat3x4; - /// Default double-precision floating-point 4x2 matrix. + /// Default double-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef highp_f64mat4x2 f64mat4x2; - /// Default double-precision floating-point 4x3 matrix. + /// Default double-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef highp_f64mat4x3 f64mat4x3; - /// Default double-precision floating-point 4x4 matrix. + /// Default double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef highp_f64mat4x4 f64mat4x4; - /// Default double-precision floating-point 2x2 matrix. + /// Default double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef f64mat2x2 f64mat2; - /// Default double-precision floating-point 3x3 matrix. + /// Default double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef f64mat3x3 f64mat3; - /// Default double-precision floating-point 4x4 matrix. + /// Default double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef f64mat4x4 f64mat4; - /// Default double-precision floating-point quaternion. + /// Default double-qualifier floating-point quaternion. /// @see gtc_type_precision typedef highp_f64quat f64quat; #endif diff --git a/glm/glm.hpp b/glm/glm.hpp index 284648ec..6d488490 100644 --- a/glm/glm.hpp +++ b/glm/glm.hpp @@ -7,7 +7,7 @@ /// /// The GLM core consists of @ref core_types "C++ types that mirror GLSL types" and /// C++ functions that mirror the GLSL functions. It also includes -/// @ref core_precision "a set of precision-based types" that can be used in the appropriate +/// @ref core_precision "a set of qualifier-based types" that can be used in the appropriate /// functions. The C++ types are all based on a basic set of @ref core_template "template types". /// /// The best documentation for GLM Core is the current GLSL specification, @@ -27,16 +27,16 @@ /// /// @defgroup core_precision Precision types /// -/// @brief Non-GLSL types that are used to define precision-based types. +/// @brief Non-GLSL types that are used to define qualifier-based types. /// -/// The GLSL language allows the user to define the precision of a particular variable. -/// In OpenGL's GLSL, these precision qualifiers have no effect; they are there for compatibility -/// with OpenGL ES's precision qualifiers, where they @em do have an effect. +/// The GLSL language allows the user to define the qualifier of a particular variable. +/// In OpenGL's GLSL, these qualifier qualifiers have no effect; they are there for compatibility +/// with OpenGL ES's qualifier qualifiers, where they @em do have an effect. /// -/// C++ has no language equivalent to precision qualifiers. So GLM provides the next-best thing: -/// a number of typedefs of the @ref core_template that use a particular precision. +/// C++ has no language equivalent to qualifier qualifiers. So GLM provides the next-best thing: +/// a number of typedefs of the @ref core_template that use a particular qualifier. /// -/// None of these types make any guarantees about the actual precision used. +/// None of these types make any guarantees about the actual qualifier used. /// /// @ingroup core /// diff --git a/glm/gtc/bitfield.hpp b/glm/gtc/bitfield.hpp index cbeb84d8..2d09fba5 100644 --- a/glm/gtc/bitfield.hpp +++ b/glm/gtc/bitfield.hpp @@ -16,7 +16,7 @@ #pragma once // Dependencies -#include "../detail/precision.hpp" +#include "../detail/qualifier.hpp" #include "../detail/type_int.hpp" #include "../detail/_vectorize.hpp" #include @@ -39,7 +39,7 @@ namespace glm /// Build a mask of 'count' bits /// /// @see gtc_bitfield - template class vecIUType> + template class vecIUType> GLM_FUNC_DECL vecIUType mask(vecIUType const & v); /// Rotate all bits to the right. All the bits dropped in the right side are inserted back on the left side. @@ -51,8 +51,8 @@ namespace glm /// Rotate all bits to the right. All the bits dropped in the right side are inserted back on the left side. /// /// @see gtc_bitfield - template class vecType> - GLM_FUNC_DECL vecType bitfieldRotateRight(vecType const & In, int Shift); + template + GLM_FUNC_DECL vec bitfieldRotateRight(vec const & In, int Shift); /// Rotate all bits to the left. All the bits dropped in the left side are inserted back on the right side. /// @@ -63,8 +63,8 @@ namespace glm /// Rotate all bits to the left. All the bits dropped in the left side are inserted back on the right side. /// /// @see gtc_bitfield - template class vecType> - GLM_FUNC_DECL vecType bitfieldRotateLeft(vecType const & In, int Shift); + template + GLM_FUNC_DECL vec bitfieldRotateLeft(vec const & In, int Shift); /// Set to 1 a range of bits. /// @@ -75,8 +75,8 @@ namespace glm /// Set to 1 a range of bits. /// /// @see gtc_bitfield - template class vecType> - GLM_FUNC_DECL vecType bitfieldFillOne(vecType const & Value, int FirstBit, int BitCount); + template + GLM_FUNC_DECL vec bitfieldFillOne(vec const & Value, int FirstBit, int BitCount); /// Set to 0 a range of bits. /// @@ -87,8 +87,8 @@ namespace glm /// Set to 0 a range of bits. /// /// @see gtc_bitfield - template class vecType> - GLM_FUNC_DECL vecType bitfieldFillZero(vecType const & Value, int FirstBit, int BitCount); + template + GLM_FUNC_DECL vec bitfieldFillZero(vec const & Value, int FirstBit, int BitCount); /// Interleaves the bits of x and y. /// The first bit is the first bit of x followed by the first bit of y. diff --git a/glm/gtc/bitfield.inl b/glm/gtc/bitfield.inl index 6be01e7e..d3490136 100644 --- a/glm/gtc/bitfield.inl +++ b/glm/gtc/bitfield.inl @@ -230,7 +230,7 @@ namespace detail return Bits >= sizeof(genIUType) * 8 ? ~static_cast(0) : (static_cast(1) << Bits) - static_cast(1); } - template class vecIUType> + template class vecIUType> GLM_FUNC_QUALIFIER vecIUType mask(vecIUType const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'mask' accepts only integer values"); @@ -247,8 +247,8 @@ namespace detail return (In << static_cast(Shift)) | (In >> static_cast(BitSize - Shift)); } - template class vecType> - GLM_FUNC_QUALIFIER vecType bitfieldRotateRight(vecType const & In, int Shift) + template + GLM_FUNC_QUALIFIER vec bitfieldRotateRight(vec const & In, int Shift) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldRotateRight' accepts only integer values"); @@ -265,8 +265,8 @@ namespace detail return (In >> static_cast(Shift)) | (In << static_cast(BitSize - Shift)); } - template class vecType> - GLM_FUNC_QUALIFIER vecType bitfieldRotateLeft(vecType const& In, int Shift) + template + GLM_FUNC_QUALIFIER vec bitfieldRotateLeft(vec const& In, int Shift) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldRotateLeft' accepts only integer values"); @@ -280,8 +280,8 @@ namespace detail return Value | static_cast(mask(BitCount) << FirstBit); } - template class vecType> - GLM_FUNC_QUALIFIER vecType bitfieldFillOne(vecType const& Value, int FirstBit, int BitCount) + template + GLM_FUNC_QUALIFIER vec bitfieldFillOne(vec const& Value, int FirstBit, int BitCount) { return Value | static_cast(mask(BitCount) << FirstBit); } @@ -292,8 +292,8 @@ namespace detail return Value & static_cast(~(mask(BitCount) << FirstBit)); } - template class vecType> - GLM_FUNC_QUALIFIER vecType bitfieldFillZero(vecType const& Value, int FirstBit, int BitCount) + template + GLM_FUNC_QUALIFIER vec bitfieldFillZero(vec const& Value, int FirstBit, int BitCount) { return Value & static_cast(~(mask(BitCount) << FirstBit)); } diff --git a/glm/gtc/color_space.hpp b/glm/gtc/color_space.hpp index da300d93..4251f492 100644 --- a/glm/gtc/color_space.hpp +++ b/glm/gtc/color_space.hpp @@ -15,7 +15,7 @@ // Dependencies #include "../detail/setup.hpp" -#include "../detail/precision.hpp" +#include "../detail/qualifier.hpp" #include "../exponential.hpp" #include "../vec3.hpp" #include "../vec4.hpp" @@ -32,23 +32,23 @@ namespace glm /// Convert a linear color to sRGB color using a standard gamma correction. /// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb - template class vecType> - GLM_FUNC_DECL vecType convertLinearToSRGB(vecType const & ColorLinear); + template + GLM_FUNC_DECL vec convertLinearToSRGB(vec const & ColorLinear); /// Convert a linear color to sRGB color using a custom gamma correction. /// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb - template class vecType> - GLM_FUNC_DECL vecType convertLinearToSRGB(vecType const & ColorLinear, T Gamma); + template + GLM_FUNC_DECL vec convertLinearToSRGB(vec const & ColorLinear, T Gamma); /// Convert a sRGB color to linear color using a standard gamma correction. /// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb - template class vecType> - GLM_FUNC_DECL vecType convertSRGBToLinear(vecType const & ColorSRGB); + template + GLM_FUNC_DECL vec convertSRGBToLinear(vec const & ColorSRGB); /// Convert a sRGB color to linear color using a custom gamma correction. // IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb - template class vecType> - GLM_FUNC_DECL vecType convertSRGBToLinear(vecType const & ColorSRGB, T Gamma); + template + GLM_FUNC_DECL vec convertSRGBToLinear(vec const & ColorSRGB, T Gamma); /// @} } //namespace glm diff --git a/glm/gtc/color_space.inl b/glm/gtc/color_space.inl index 56341dea..debde485 100644 --- a/glm/gtc/color_space.inl +++ b/glm/gtc/color_space.inl @@ -4,55 +4,55 @@ namespace glm{ namespace detail { - template class vecType> + template struct compute_rgbToSrgb { - GLM_FUNC_QUALIFIER static vecType call(vecType const& ColorRGB, T GammaCorrection) + GLM_FUNC_QUALIFIER static vec call(vec const& ColorRGB, T GammaCorrection) { - vecType const ClampedColor(clamp(ColorRGB, static_cast(0), static_cast(1))); + vec const ClampedColor(clamp(ColorRGB, static_cast(0), static_cast(1))); return mix( - pow(ClampedColor, vecType(GammaCorrection)) * static_cast(1.055) - static_cast(0.055), + pow(ClampedColor, vec(GammaCorrection)) * static_cast(1.055) - static_cast(0.055), ClampedColor * static_cast(12.92), - lessThan(ClampedColor, vecType(static_cast(0.0031308)))); + lessThan(ClampedColor, vec(static_cast(0.0031308)))); } }; - template - struct compute_rgbToSrgb<4, T, P, vec> + template + struct compute_rgbToSrgb<4, T, P> { GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const& ColorRGB, T GammaCorrection) { - return vec<4, T, P>(compute_rgbToSrgb<3, T, P, vec>::call(vec<3, T, P>(ColorRGB), GammaCorrection), ColorRGB.w); + return vec<4, T, P>(compute_rgbToSrgb<3, T, P>::call(vec<3, T, P>(ColorRGB), GammaCorrection), ColorRGB.w); } }; - template class vecType> + template struct compute_srgbToRgb { - GLM_FUNC_QUALIFIER static vecType call(vecType const& ColorSRGB, T Gamma) + GLM_FUNC_QUALIFIER static vec call(vec const& ColorSRGB, T Gamma) { return mix( - pow((ColorSRGB + static_cast(0.055)) * static_cast(0.94786729857819905213270142180095), vecType(Gamma)), + pow((ColorSRGB + static_cast(0.055)) * static_cast(0.94786729857819905213270142180095), vec(Gamma)), ColorSRGB * static_cast(0.07739938080495356037151702786378), - lessThanEqual(ColorSRGB, vecType(static_cast(0.04045)))); + lessThanEqual(ColorSRGB, vec(static_cast(0.04045)))); } }; - template - struct compute_srgbToRgb<4, T, P, vec> + template + struct compute_srgbToRgb<4, T, P> { GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const& ColorSRGB, T Gamma) { - return vec<4, T, P>(compute_srgbToRgb<3, T, P, vec>::call(vec<3, T, P>(ColorSRGB), Gamma), ColorSRGB.w); + return vec<4, T, P>(compute_srgbToRgb<3, T, P>::call(vec<3, T, P>(ColorSRGB), Gamma), ColorSRGB.w); } }; }//namespace detail - template class vecType> - GLM_FUNC_QUALIFIER vecType convertLinearToSRGB(vecType const& ColorLinear) + template + GLM_FUNC_QUALIFIER vec convertLinearToSRGB(vec const& ColorLinear) { - return detail::compute_rgbToSrgb::call(ColorLinear, static_cast(0.41666)); + return detail::compute_rgbToSrgb::call(ColorLinear, static_cast(0.41666)); } // Based on Ian Taylor http://chilliant.blogspot.fr/2012/08/srgb-approximations-for-hlsl.html @@ -65,21 +65,21 @@ namespace detail return 0.662002687f * S1 + 0.684122060f * S2 - 0.323583601f * S3 - 0.0225411470f * ColorLinear; } - template class vecType> - GLM_FUNC_QUALIFIER vecType convertLinearToSRGB(vecType const& ColorLinear, T Gamma) + template + GLM_FUNC_QUALIFIER vec convertLinearToSRGB(vec const& ColorLinear, T Gamma) { - return detail::compute_rgbToSrgb::call(ColorLinear, static_cast(1) / Gamma); + return detail::compute_rgbToSrgb::call(ColorLinear, static_cast(1) / Gamma); } - template class vecType> - GLM_FUNC_QUALIFIER vecType convertSRGBToLinear(vecType const& ColorSRGB) + template + GLM_FUNC_QUALIFIER vec convertSRGBToLinear(vec const& ColorSRGB) { - return detail::compute_srgbToRgb::call(ColorSRGB, static_cast(2.4)); + return detail::compute_srgbToRgb::call(ColorSRGB, static_cast(2.4)); } - template class vecType> - GLM_FUNC_QUALIFIER vecType convertSRGBToLinear(vecType const& ColorSRGB, T Gamma) + template + GLM_FUNC_QUALIFIER vec convertSRGBToLinear(vec const& ColorSRGB, T Gamma) { - return detail::compute_srgbToRgb::call(ColorSRGB, Gamma); + return detail::compute_srgbToRgb::call(ColorSRGB, Gamma); } }//namespace glm diff --git a/glm/gtc/epsilon.hpp b/glm/gtc/epsilon.hpp index 703df1e4..fc0dbfae 100644 --- a/glm/gtc/epsilon.hpp +++ b/glm/gtc/epsilon.hpp @@ -15,7 +15,7 @@ // Dependencies #include "../detail/setup.hpp" -#include "../detail/precision.hpp" +#include "../detail/qualifier.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTC_epsilon extension included") @@ -30,7 +30,7 @@ namespace glm /// True if this expression is satisfied. /// /// @see gtc_epsilon - template + template GLM_FUNC_DECL vec epsilonEqual(vec const& x, vec const& y, T const & epsilon); /// Returns the component-wise comparison of |x - y| < epsilon. @@ -44,7 +44,7 @@ namespace glm /// True if this expression is not satisfied. /// /// @see gtc_epsilon - template + template GLM_FUNC_DECL vec epsilonNotEqual(vec const& x, vec const& y, T const & epsilon); /// Returns the component-wise comparison of |x - y| >= epsilon. diff --git a/glm/gtc/epsilon.inl b/glm/gtc/epsilon.inl index 53dae576..4e6eaa4a 100644 --- a/glm/gtc/epsilon.inl +++ b/glm/gtc/epsilon.inl @@ -33,13 +33,13 @@ namespace glm return abs(x - y) < epsilon; } - template + template GLM_FUNC_QUALIFIER vec epsilonEqual(vec const& x, vec const& y, T const& epsilon) { return lessThan(abs(x - y), vec(epsilon)); } - template + template GLM_FUNC_QUALIFIER vec epsilonEqual(vec const& x, vec const& y, vec const& epsilon) { return lessThan(abs(x - y), vec(epsilon)); @@ -57,26 +57,26 @@ namespace glm return abs(x - y) >= epsilon; } - template + template GLM_FUNC_QUALIFIER vec epsilonNotEqual(vec const& x, vec const& y, T const& epsilon) { return greaterThanEqual(abs(x - y), vec(epsilon)); } - template + template GLM_FUNC_QUALIFIER vec epsilonNotEqual(vec const& x, vec const& y, vec const& epsilon) { return greaterThanEqual(abs(x - y), vec(epsilon)); } - template + template GLM_FUNC_QUALIFIER vec<4, bool, P> epsilonEqual(tquat const& x, tquat const & y, T const& epsilon) { vec<4, T, P> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w); return lessThan(abs(v), vec<4, T, P>(epsilon)); } - template + template GLM_FUNC_QUALIFIER vec<4, bool, P> epsilonNotEqual(tquat const& x, tquat const& y, T const& epsilon) { vec<4, T, P> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w); diff --git a/glm/gtc/functions.hpp b/glm/gtc/functions.hpp index 89048cc1..ef7796af 100644 --- a/glm/gtc/functions.hpp +++ b/glm/gtc/functions.hpp @@ -15,7 +15,7 @@ // Dependencies #include "../detail/setup.hpp" -#include "../detail/precision.hpp" +#include "../detail/qualifier.hpp" #include "../detail/type_vec2.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) @@ -39,7 +39,7 @@ namespace glm /// 2D gauss function /// /// @see gtc_epsilon - template + template GLM_FUNC_DECL T gauss( vec<2, T, P> const& Coord, vec<2, T, P> const& ExpectedValue, diff --git a/glm/gtc/functions.inl b/glm/gtc/functions.inl index b332e9eb..be1c276b 100644 --- a/glm/gtc/functions.inl +++ b/glm/gtc/functions.inl @@ -16,7 +16,7 @@ namespace glm return exp(-((x - ExpectedValue) * (x - ExpectedValue)) / (static_cast(2) * StandardDeviation * StandardDeviation)) / (StandardDeviation * sqrt(static_cast(6.28318530717958647692528676655900576))); } - template + template GLM_FUNC_QUALIFIER T gauss ( vec<2, T, P> const& Coord, diff --git a/glm/gtc/integer.hpp b/glm/gtc/integer.hpp index d4810b52..275348ee 100644 --- a/glm/gtc/integer.hpp +++ b/glm/gtc/integer.hpp @@ -15,7 +15,7 @@ // Dependencies #include "../detail/setup.hpp" -#include "../detail/precision.hpp" +#include "../detail/qualifier.hpp" #include "../detail/func_common.hpp" #include "../detail/func_integer.hpp" #include "../detail/func_exponential.hpp" @@ -54,7 +54,7 @@ namespace glm /// @see gtc_integer /// @see GLSL mod man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec mod(vec const& x, T y); /// Modulus. Returns x % y @@ -65,7 +65,7 @@ namespace glm /// @see gtc_integer /// @see GLSL mod man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions - template + template GLM_FUNC_DECL vec mod(vec const& x, vec const& y); /// Returns a value equal to the nearest integer to x. @@ -77,7 +77,7 @@ namespace glm /// /// @see GLSL round man page /// @see gtc_integer - template + template GLM_FUNC_DECL vec iround(vec const& x); /// Returns a value equal to the nearest integer to x. @@ -89,7 +89,7 @@ namespace glm /// /// @see GLSL round man page /// @see gtc_integer - template + template GLM_FUNC_DECL vec uround(vec const& x); /// @} diff --git a/glm/gtc/integer.inl b/glm/gtc/integer.inl index 8b44e171..a8258fc6 100644 --- a/glm/gtc/integer.inl +++ b/glm/gtc/integer.inl @@ -4,7 +4,7 @@ namespace glm{ namespace detail { - template + template struct compute_log2 { GLM_FUNC_QUALIFIER static vec call(vec const& v) @@ -16,7 +16,7 @@ namespace detail }; # if GLM_HAS_BITSCAN_WINDOWS - template + template struct compute_log2<4, int, P, false, Aligned> { GLM_FUNC_QUALIFIER static vec<4, int, P> call(vec<4, int, P> const& v) @@ -40,7 +40,7 @@ namespace detail return static_cast(x + static_cast(0.5)); } - template + template GLM_FUNC_QUALIFIER vec iround(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'iround' only accept floating-point inputs"); @@ -58,7 +58,7 @@ namespace detail return static_cast(x + static_cast(0.5)); } - template + template GLM_FUNC_QUALIFIER vec uround(vec const& x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'uround' only accept floating-point inputs"); diff --git a/glm/gtc/matrix_integer.hpp b/glm/gtc/matrix_integer.hpp index 0f2c0d99..13139b84 100644 --- a/glm/gtc/matrix_integer.hpp +++ b/glm/gtc/matrix_integer.hpp @@ -31,300 +31,300 @@ namespace glm /// @addtogroup gtc_matrix_integer /// @{ - /// High-precision signed integer 2x2 matrix. + /// High-qualifier signed integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, int, highp> highp_imat2; - /// High-precision signed integer 3x3 matrix. + /// High-qualifier signed integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, int, highp> highp_imat3; - /// High-precision signed integer 4x4 matrix. + /// High-qualifier signed integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, int, highp> highp_imat4; - /// High-precision signed integer 2x2 matrix. + /// High-qualifier signed integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, int, highp> highp_imat2x2; - /// High-precision signed integer 2x3 matrix. + /// High-qualifier signed integer 2x3 matrix. /// @see gtc_matrix_integer typedef mat<2, 3, int, highp> highp_imat2x3; - /// High-precision signed integer 2x4 matrix. + /// High-qualifier signed integer 2x4 matrix. /// @see gtc_matrix_integer typedef mat<2, 4, int, highp> highp_imat2x4; - /// High-precision signed integer 3x2 matrix. + /// High-qualifier signed integer 3x2 matrix. /// @see gtc_matrix_integer typedef mat<3, 2, int, highp> highp_imat3x2; - /// High-precision signed integer 3x3 matrix. + /// High-qualifier signed integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, int, highp> highp_imat3x3; - /// High-precision signed integer 3x4 matrix. + /// High-qualifier signed integer 3x4 matrix. /// @see gtc_matrix_integer typedef mat<3, 4, int, highp> highp_imat3x4; - /// High-precision signed integer 4x2 matrix. + /// High-qualifier signed integer 4x2 matrix. /// @see gtc_matrix_integer typedef mat<4, 2, int, highp> highp_imat4x2; - /// High-precision signed integer 4x3 matrix. + /// High-qualifier signed integer 4x3 matrix. /// @see gtc_matrix_integer typedef mat<4, 3, int, highp> highp_imat4x3; - /// High-precision signed integer 4x4 matrix. + /// High-qualifier signed integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, int, highp> highp_imat4x4; - /// Medium-precision signed integer 2x2 matrix. + /// Medium-qualifier signed integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, int, mediump> mediump_imat2; - /// Medium-precision signed integer 3x3 matrix. + /// Medium-qualifier signed integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, int, mediump> mediump_imat3; - /// Medium-precision signed integer 4x4 matrix. + /// Medium-qualifier signed integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, int, mediump> mediump_imat4; - /// Medium-precision signed integer 2x2 matrix. + /// Medium-qualifier signed integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, int, mediump> mediump_imat2x2; - /// Medium-precision signed integer 2x3 matrix. + /// Medium-qualifier signed integer 2x3 matrix. /// @see gtc_matrix_integer typedef mat<2, 3, int, mediump> mediump_imat2x3; - /// Medium-precision signed integer 2x4 matrix. + /// Medium-qualifier signed integer 2x4 matrix. /// @see gtc_matrix_integer typedef mat<2, 4, int, mediump> mediump_imat2x4; - /// Medium-precision signed integer 3x2 matrix. + /// Medium-qualifier signed integer 3x2 matrix. /// @see gtc_matrix_integer typedef mat<3, 2, int, mediump> mediump_imat3x2; - /// Medium-precision signed integer 3x3 matrix. + /// Medium-qualifier signed integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, int, mediump> mediump_imat3x3; - /// Medium-precision signed integer 3x4 matrix. + /// Medium-qualifier signed integer 3x4 matrix. /// @see gtc_matrix_integer typedef mat<3, 4, int, mediump> mediump_imat3x4; - /// Medium-precision signed integer 4x2 matrix. + /// Medium-qualifier signed integer 4x2 matrix. /// @see gtc_matrix_integer typedef mat<4, 2, int, mediump> mediump_imat4x2; - /// Medium-precision signed integer 4x3 matrix. + /// Medium-qualifier signed integer 4x3 matrix. /// @see gtc_matrix_integer typedef mat<4, 3, int, mediump> mediump_imat4x3; - /// Medium-precision signed integer 4x4 matrix. + /// Medium-qualifier signed integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, int, mediump> mediump_imat4x4; - /// Low-precision signed integer 2x2 matrix. + /// Low-qualifier signed integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, int, lowp> lowp_imat2; - /// Low-precision signed integer 3x3 matrix. + /// Low-qualifier signed integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, int, lowp> lowp_imat3; - /// Low-precision signed integer 4x4 matrix. + /// Low-qualifier signed integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, int, lowp> lowp_imat4; - /// Low-precision signed integer 2x2 matrix. + /// Low-qualifier signed integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, int, lowp> lowp_imat2x2; - /// Low-precision signed integer 2x3 matrix. + /// Low-qualifier signed integer 2x3 matrix. /// @see gtc_matrix_integer typedef mat<2, 3, int, lowp> lowp_imat2x3; - /// Low-precision signed integer 2x4 matrix. + /// Low-qualifier signed integer 2x4 matrix. /// @see gtc_matrix_integer typedef mat<2, 4, int, lowp> lowp_imat2x4; - /// Low-precision signed integer 3x2 matrix. + /// Low-qualifier signed integer 3x2 matrix. /// @see gtc_matrix_integer typedef mat<3, 2, int, lowp> lowp_imat3x2; - /// Low-precision signed integer 3x3 matrix. + /// Low-qualifier signed integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, int, lowp> lowp_imat3x3; - /// Low-precision signed integer 3x4 matrix. + /// Low-qualifier signed integer 3x4 matrix. /// @see gtc_matrix_integer typedef mat<3, 4, int, lowp> lowp_imat3x4; - /// Low-precision signed integer 4x2 matrix. + /// Low-qualifier signed integer 4x2 matrix. /// @see gtc_matrix_integer typedef mat<4, 2, int, lowp> lowp_imat4x2; - /// Low-precision signed integer 4x3 matrix. + /// Low-qualifier signed integer 4x3 matrix. /// @see gtc_matrix_integer typedef mat<4, 3, int, lowp> lowp_imat4x3; - /// Low-precision signed integer 4x4 matrix. + /// Low-qualifier signed integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, int, lowp> lowp_imat4x4; - /// High-precision unsigned integer 2x2 matrix. + /// High-qualifier unsigned integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, uint, highp> highp_umat2; - /// High-precision unsigned integer 3x3 matrix. + /// High-qualifier unsigned integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, uint, highp> highp_umat3; - /// High-precision unsigned integer 4x4 matrix. + /// High-qualifier unsigned integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, uint, highp> highp_umat4; - /// High-precision unsigned integer 2x2 matrix. + /// High-qualifier unsigned integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, uint, highp> highp_umat2x2; - /// High-precision unsigned integer 2x3 matrix. + /// High-qualifier unsigned integer 2x3 matrix. /// @see gtc_matrix_integer typedef mat<2, 3, uint, highp> highp_umat2x3; - /// High-precision unsigned integer 2x4 matrix. + /// High-qualifier unsigned integer 2x4 matrix. /// @see gtc_matrix_integer typedef mat<2, 4, uint, highp> highp_umat2x4; - /// High-precision unsigned integer 3x2 matrix. + /// High-qualifier unsigned integer 3x2 matrix. /// @see gtc_matrix_integer typedef mat<3, 2, uint, highp> highp_umat3x2; - /// High-precision unsigned integer 3x3 matrix. + /// High-qualifier unsigned integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, uint, highp> highp_umat3x3; - /// High-precision unsigned integer 3x4 matrix. + /// High-qualifier unsigned integer 3x4 matrix. /// @see gtc_matrix_integer typedef mat<3, 4, uint, highp> highp_umat3x4; - /// High-precision unsigned integer 4x2 matrix. + /// High-qualifier unsigned integer 4x2 matrix. /// @see gtc_matrix_integer typedef mat<4, 2, uint, highp> highp_umat4x2; - /// High-precision unsigned integer 4x3 matrix. + /// High-qualifier unsigned integer 4x3 matrix. /// @see gtc_matrix_integer typedef mat<4, 3, uint, highp> highp_umat4x3; - /// High-precision unsigned integer 4x4 matrix. + /// High-qualifier unsigned integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, uint, highp> highp_umat4x4; - /// Medium-precision unsigned integer 2x2 matrix. + /// Medium-qualifier unsigned integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, uint, mediump> mediump_umat2; - /// Medium-precision unsigned integer 3x3 matrix. + /// Medium-qualifier unsigned integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, uint, mediump> mediump_umat3; - /// Medium-precision unsigned integer 4x4 matrix. + /// Medium-qualifier unsigned integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, uint, mediump> mediump_umat4; - /// Medium-precision unsigned integer 2x2 matrix. + /// Medium-qualifier unsigned integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, uint, mediump> mediump_umat2x2; - /// Medium-precision unsigned integer 2x3 matrix. + /// Medium-qualifier unsigned integer 2x3 matrix. /// @see gtc_matrix_integer typedef mat<2, 3, uint, mediump> mediump_umat2x3; - /// Medium-precision unsigned integer 2x4 matrix. + /// Medium-qualifier unsigned integer 2x4 matrix. /// @see gtc_matrix_integer typedef mat<2, 4, uint, mediump> mediump_umat2x4; - /// Medium-precision unsigned integer 3x2 matrix. + /// Medium-qualifier unsigned integer 3x2 matrix. /// @see gtc_matrix_integer typedef mat<3, 2, uint, mediump> mediump_umat3x2; - /// Medium-precision unsigned integer 3x3 matrix. + /// Medium-qualifier unsigned integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, uint, mediump> mediump_umat3x3; - /// Medium-precision unsigned integer 3x4 matrix. + /// Medium-qualifier unsigned integer 3x4 matrix. /// @see gtc_matrix_integer typedef mat<3, 4, uint, mediump> mediump_umat3x4; - /// Medium-precision unsigned integer 4x2 matrix. + /// Medium-qualifier unsigned integer 4x2 matrix. /// @see gtc_matrix_integer typedef mat<4, 2, uint, mediump> mediump_umat4x2; - /// Medium-precision unsigned integer 4x3 matrix. + /// Medium-qualifier unsigned integer 4x3 matrix. /// @see gtc_matrix_integer typedef mat<4, 3, uint, mediump> mediump_umat4x3; - /// Medium-precision unsigned integer 4x4 matrix. + /// Medium-qualifier unsigned integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, uint, mediump> mediump_umat4x4; - /// Low-precision unsigned integer 2x2 matrix. + /// Low-qualifier unsigned integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, uint, lowp> lowp_umat2; - /// Low-precision unsigned integer 3x3 matrix. + /// Low-qualifier unsigned integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, uint, lowp> lowp_umat3; - /// Low-precision unsigned integer 4x4 matrix. + /// Low-qualifier unsigned integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, uint, lowp> lowp_umat4; - /// Low-precision unsigned integer 2x2 matrix. + /// Low-qualifier unsigned integer 2x2 matrix. /// @see gtc_matrix_integer typedef mat<2, 2, uint, lowp> lowp_umat2x2; - /// Low-precision unsigned integer 2x3 matrix. + /// Low-qualifier unsigned integer 2x3 matrix. /// @see gtc_matrix_integer typedef mat<2, 3, uint, lowp> lowp_umat2x3; - /// Low-precision unsigned integer 2x4 matrix. + /// Low-qualifier unsigned integer 2x4 matrix. /// @see gtc_matrix_integer typedef mat<2, 4, uint, lowp> lowp_umat2x4; - /// Low-precision unsigned integer 3x2 matrix. + /// Low-qualifier unsigned integer 3x2 matrix. /// @see gtc_matrix_integer typedef mat<3, 2, uint, lowp> lowp_umat3x2; - /// Low-precision unsigned integer 3x3 matrix. + /// Low-qualifier unsigned integer 3x3 matrix. /// @see gtc_matrix_integer typedef mat<3, 3, uint, lowp> lowp_umat3x3; - /// Low-precision unsigned integer 3x4 matrix. + /// Low-qualifier unsigned integer 3x4 matrix. /// @see gtc_matrix_integer typedef mat<3, 4, uint, lowp> lowp_umat3x4; - /// Low-precision unsigned integer 4x2 matrix. + /// Low-qualifier unsigned integer 4x2 matrix. /// @see gtc_matrix_integer typedef mat<4, 2, uint, lowp> lowp_umat4x2; - /// Low-precision unsigned integer 4x3 matrix. + /// Low-qualifier unsigned integer 4x3 matrix. /// @see gtc_matrix_integer typedef mat<4, 3, uint, lowp> lowp_umat4x3; - /// Low-precision unsigned integer 4x4 matrix. + /// Low-qualifier unsigned integer 4x4 matrix. /// @see gtc_matrix_integer typedef mat<4, 4, uint, lowp> lowp_umat4x4; diff --git a/glm/gtc/matrix_inverse.hpp b/glm/gtc/matrix_inverse.hpp index bbc73800..3d1cd210 100644 --- a/glm/gtc/matrix_inverse.hpp +++ b/glm/gtc/matrix_inverse.hpp @@ -30,7 +30,7 @@ namespace glm /// Fast matrix inverse for affine matrix. /// /// @param m Input matrix to invert. - /// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-precision floating point value is highly innacurate. + /// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-qualifier floating point value is highly innacurate. /// @see gtc_matrix_inverse template GLM_FUNC_DECL genType affineInverse(genType const & m); @@ -38,7 +38,7 @@ namespace glm /// Compute the inverse transpose of a matrix. /// /// @param m Input matrix to invert transpose. - /// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-precision floating point value is highly innacurate. + /// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-qualifier floating point value is highly innacurate. /// @see gtc_matrix_inverse template GLM_FUNC_DECL genType inverseTranspose(genType const & m); diff --git a/glm/gtc/matrix_inverse.inl b/glm/gtc/matrix_inverse.inl index 0d1f9f26..88f2ad68 100644 --- a/glm/gtc/matrix_inverse.inl +++ b/glm/gtc/matrix_inverse.inl @@ -3,7 +3,7 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> affineInverse(mat<3, 3, T, P> const & m) { mat<2, 2, T, P> const Inv(inverse(mat<2, 2, T, P>(m))); @@ -14,7 +14,7 @@ namespace glm vec<3, T, P>(-Inv * vec<2, T, P>(m[2]), static_cast(1))); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> affineInverse(mat<4, 4, T, P> const & m) { mat<3, 3, T, P> const Inv(inverse(mat<3, 3, T, P>(m))); @@ -26,7 +26,7 @@ namespace glm vec<4, T, P>(-Inv * vec<3, T, P>(m[3]), static_cast(1))); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> inverseTranspose(mat<2, 2, T, P> const & m) { T Determinant = m[0][0] * m[1][1] - m[1][0] * m[0][1]; @@ -40,7 +40,7 @@ namespace glm return Inverse; } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> inverseTranspose(mat<3, 3, T, P> const & m) { T Determinant = @@ -63,7 +63,7 @@ namespace glm return Inverse; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> inverseTranspose(mat<4, 4, T, P> const & m) { T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; diff --git a/glm/gtc/matrix_transform.hpp b/glm/gtc/matrix_transform.hpp index bbbbcfc2..94d09138 100644 --- a/glm/gtc/matrix_transform.hpp +++ b/glm/gtc/matrix_transform.hpp @@ -54,7 +54,7 @@ namespace glm /// @see gtc_matrix_transform /// @see - translate(mat<4, 4, T, P> const & m, T x, T y, T z) /// @see - translate(vec<3, T, P> const & v) - template + template GLM_FUNC_DECL mat<4, 4, T, P> translate( mat<4, 4, T, P> const& m, vec<3, T, P> const & v); @@ -68,7 +68,7 @@ namespace glm /// @see gtc_matrix_transform /// @see - rotate(mat<4, 4, T, P> const & m, T angle, T x, T y, T z) /// @see - rotate(T angle, vec<3, T, P> const & v) - template + template GLM_FUNC_DECL mat<4, 4, T, P> rotate( mat<4, 4, T, P> const& m, T angle, @@ -82,7 +82,7 @@ namespace glm /// @see gtc_matrix_transform /// @see - scale(mat<4, 4, T, P> const & m, T x, T y, T z) /// @see - scale(vec<3, T, P> const & v) - template + template GLM_FUNC_DECL mat<4, 4, T, P> scale( mat<4, 4, T, P> const& m, vec<3, T, P> const & v); @@ -382,7 +382,7 @@ namespace glm /// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double. /// @tparam U Currently supported: Floating-point types and integer types. /// @see gtc_matrix_transform - template + template GLM_FUNC_DECL vec<3, T, P> project( vec<3, T, P> const & obj, mat<4, 4, T, P> const& model, @@ -399,7 +399,7 @@ namespace glm /// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double. /// @tparam U Currently supported: Floating-point types and integer types. /// @see gtc_matrix_transform - template + template GLM_FUNC_DECL vec<3, T, P> unProject( vec<3, T, P> const & win, mat<4, 4, T, P> const& model, @@ -414,7 +414,7 @@ namespace glm /// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double. /// @tparam U Currently supported: Floating-point types and integer types. /// @see gtc_matrix_transform - template + template GLM_FUNC_DECL mat<4, 4, T, P> pickMatrix( vec<2, T, P> const & center, vec<2, T, P> const & delta, @@ -427,7 +427,7 @@ namespace glm /// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1) /// @see gtc_matrix_transform /// @see - frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal) frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal) - template + template GLM_FUNC_DECL mat<4, 4, T, P> lookAt( vec<3, T, P> const & eye, vec<3, T, P> const & center, @@ -440,7 +440,7 @@ namespace glm /// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1) /// @see gtc_matrix_transform /// @see - frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal) frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal) - template + template GLM_FUNC_DECL mat<4, 4, T, P> lookAtRH( vec<3, T, P> const & eye, vec<3, T, P> const & center, @@ -453,7 +453,7 @@ namespace glm /// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1) /// @see gtc_matrix_transform /// @see - frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal) frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal) - template + template GLM_FUNC_DECL mat<4, 4, T, P> lookAtLH( vec<3, T, P> const & eye, vec<3, T, P> const & center, diff --git a/glm/gtc/matrix_transform.inl b/glm/gtc/matrix_transform.inl index 2bb78d19..7fdf7268 100644 --- a/glm/gtc/matrix_transform.inl +++ b/glm/gtc/matrix_transform.inl @@ -7,7 +7,7 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> translate(mat<4, 4, T, P> const & m, vec<3, T, P> const & v) { mat<4, 4, T, P> Result(m); @@ -15,7 +15,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> rotate(mat<4, 4, T, P> const & m, T angle, vec<3, T, P> const & v) { T const a = angle; @@ -46,7 +46,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> rotate_slow(mat<4, 4, T, P> const & m, T angle, vec<3, T, P> const & v) { T const a = angle; @@ -75,7 +75,7 @@ namespace glm return m * Result; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> scale(mat<4, 4, T, P> const & m, vec<3, T, P> const & v) { mat<4, 4, T, P> Result; @@ -86,7 +86,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> scale_slow(mat<4, 4, T, P> const & m, vec<3, T, P> const & v) { mat<4, 4, T, P> Result(T(1)); @@ -435,7 +435,7 @@ namespace glm return tweakedInfinitePerspective(fovy, aspect, zNear, epsilon()); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> project ( vec<3, T, P> const & obj, @@ -461,7 +461,7 @@ namespace glm return vec<3, T, P>(tmp); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> unProject ( vec<3, T, P> const & win, @@ -488,7 +488,7 @@ namespace glm return vec<3, T, P>(obj); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> pickMatrix(vec<2, T, P> const & center, vec<2, T, P> const & delta, vec<4, U, P> const & viewport) { assert(delta.x > static_cast(0) && delta.y > static_cast(0)); @@ -507,7 +507,7 @@ namespace glm return scale(Result, vec<3, T, P>(static_cast(viewport[2]) / delta.x, static_cast(viewport[3]) / delta.y, static_cast(1))); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> lookAt(vec<3, T, P> const & eye, vec<3, T, P> const & center, vec<3, T, P> const & up) { # if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED @@ -517,7 +517,7 @@ namespace glm # endif } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> lookAtRH ( vec<3, T, P> const & eye, @@ -545,7 +545,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> lookAtLH ( vec<3, T, P> const & eye, diff --git a/glm/gtc/noise.hpp b/glm/gtc/noise.hpp index 870c5fbc..eab5593a 100644 --- a/glm/gtc/noise.hpp +++ b/glm/gtc/noise.hpp @@ -17,7 +17,7 @@ // Dependencies #include "../detail/setup.hpp" -#include "../detail/precision.hpp" +#include "../detail/qualifier.hpp" #include "../detail/_noise.hpp" #include "../geometric.hpp" #include "../common.hpp" @@ -37,22 +37,22 @@ namespace glm /// Classic perlin noise. /// @see gtc_noise - template class vecType> + template GLM_FUNC_DECL T perlin( - vecType const& p); + vec const& p); /// Periodic perlin noise. /// @see gtc_noise - template class vecType> + template GLM_FUNC_DECL T perlin( - vecType const& p, - vecType const& rep); + vec const& p, + vec const& rep); /// Simplex noise. /// @see gtc_noise - template class vecType> + template GLM_FUNC_DECL T simplex( - vecType const& p); + vec const& p); /// @} }//namespace glm diff --git a/glm/gtc/noise.inl b/glm/gtc/noise.inl index d3a676f2..55ecc6f9 100644 --- a/glm/gtc/noise.inl +++ b/glm/gtc/noise.inl @@ -9,7 +9,7 @@ namespace glm{ namespace gtc { - template + template GLM_FUNC_QUALIFIER vec<4, T, P> grad4(T const & j, vec<4, T, P> const & ip) { vec<3, T, P> pXYZ = floor(fract(vec<3, T, P>(j) * vec<3, T, P>(ip)) * T(7)) * ip[2] - T(1); @@ -21,7 +21,7 @@ namespace gtc }//namespace gtc // Classic Perlin noise - template + template GLM_FUNC_QUALIFIER T perlin(vec<2, T, P> const & Position) { vec<4, T, P> Pi = glm::floor(vec<4, T, P>(Position.x, Position.y, Position.x, Position.y)) + vec<4, T, P>(0.0, 0.0, 1.0, 1.0); @@ -62,7 +62,7 @@ namespace gtc } // Classic Perlin noise - template + template GLM_FUNC_QUALIFIER T perlin(vec<3, T, P> const & Position) { vec<3, T, P> Pi0 = floor(Position); // Integer part for indexing @@ -133,7 +133,7 @@ namespace gtc } /* // Classic Perlin noise - template + template GLM_FUNC_QUALIFIER T perlin(vec<3, T, P> const & P) { vec<3, T, P> Pi0 = floor(P); // Integer part for indexing @@ -206,7 +206,7 @@ namespace gtc } */ // Classic Perlin noise - template + template GLM_FUNC_QUALIFIER T perlin(vec<4, T, P> const & Position) { vec<4, T, P> Pi0 = floor(Position); // Integer part for indexing @@ -342,7 +342,7 @@ namespace gtc } // Classic Perlin noise, periodic variant - template + template GLM_FUNC_QUALIFIER T perlin(vec<2, T, P> const & Position, vec<2, T, P> const & rep) { vec<4, T, P> Pi = floor(vec<4, T, P>(Position.x, Position.y, Position.x, Position.y)) + vec<4, T, P>(0.0, 0.0, 1.0, 1.0); @@ -384,7 +384,7 @@ namespace gtc } // Classic Perlin noise, periodic variant - template + template GLM_FUNC_QUALIFIER T perlin(vec<3, T, P> const & Position, vec<3, T, P> const & rep) { vec<3, T, P> Pi0 = mod(floor(Position), rep); // Integer part, modulo period @@ -455,7 +455,7 @@ namespace gtc } // Classic Perlin noise, periodic version - template + template GLM_FUNC_QUALIFIER T perlin(vec<4, T, P> const & Position, vec<4, T, P> const & rep) { vec<4, T, P> Pi0 = mod(floor(Position), rep); // Integer part modulo rep @@ -588,7 +588,7 @@ namespace gtc return T(2.2) * n_xyzw; } - template + template GLM_FUNC_QUALIFIER T simplex(glm::vec<2, T, P> const & v) { vec<4, T, P> const C = vec<4, T, P>( @@ -645,7 +645,7 @@ namespace gtc return T(130) * dot(m, g); } - template + template GLM_FUNC_QUALIFIER T simplex(vec<3, T, P> const & v) { vec<2, T, P> const C(1.0 / 6.0, 1.0 / 3.0); @@ -720,7 +720,7 @@ namespace gtc return T(42) * dot(m * m, vec<4, T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3))); } - template + template GLM_FUNC_QUALIFIER T simplex(vec<4, T, P> const & v) { vec<4, T, P> const C( diff --git a/glm/gtc/packing.hpp b/glm/gtc/packing.hpp index d34370a5..6d66e2ba 100644 --- a/glm/gtc/packing.hpp +++ b/glm/gtc/packing.hpp @@ -477,7 +477,7 @@ namespace glm /// @see gtc_packing /// @see vec<3, T, P> unpackRGBM(vec<4, T, P> const & p) /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions - template + template GLM_FUNC_DECL vec<4, T, P> packRGBM(vec<3, T, P> const & rgb); /// Returns a floating-point vector with components obtained by reinterpreting an integer vector as 16-bit floating-point numbers and converting them to 32-bit floating-point values. @@ -487,7 +487,7 @@ namespace glm /// @see gtc_packing /// @see vec<4, T, P> packRGBM(vec<3, float, P> const & v) /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions - template + template GLM_FUNC_DECL vec<3, T, P> unpackRGBM(vec<4, T, P> const & rgbm); /// Returns an unsigned integer vector obtained by converting the components of a floating-point vector @@ -496,47 +496,47 @@ namespace glm /// the forth component specifies the 16 most-significant bits. /// /// @see gtc_packing - /// @see vecType unpackHalf(vecType const & p) + /// @see vec unpackHalf(vec const & p) /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions - template class vecType> - GLM_FUNC_DECL vecType packHalf(vecType const & v); + template + GLM_FUNC_DECL vec packHalf(vec const & v); /// Returns a floating-point vector with components obtained by reinterpreting an integer vector as 16-bit floating-point numbers and converting them to 32-bit floating-point values. /// The first component of the vector is obtained from the 16 least-significant bits of v; /// the forth component is obtained from the 16 most-significant bits of v. /// /// @see gtc_packing - /// @see vecType packHalf(vecType const & v) + /// @see vec packHalf(vec const & v) /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions - template class vecType> - GLM_FUNC_DECL vecType unpackHalf(vecType const & p); + template + GLM_FUNC_DECL vec unpackHalf(vec const & p); /// Convert each component of the normalized floating-point vector into unsigned integer values. /// /// @see gtc_packing - /// @see vecType unpackUnorm(vecType const & p); - template + /// @see vec unpackUnorm(vec const & p); + template GLM_FUNC_DECL vec packUnorm(vec const & v); /// Convert a packed integer to a normalized floating-point vector. /// /// @see gtc_packing - /// @see vecType packUnorm(vecType const & v) - template + /// @see vec packUnorm(vec const & v) + template GLM_FUNC_DECL vec unpackUnorm(vec const & v); /// Convert each component of the normalized floating-point vector into signed integer values. /// /// @see gtc_packing - /// @see vecType unpackSnorm(vecType const & p); - template + /// @see vec unpackSnorm(vec const & p); + template GLM_FUNC_DECL vec packSnorm(vec const & v); /// Convert a packed integer to a normalized floating-point vector. /// /// @see gtc_packing - /// @see vecType packSnorm(vecType const & v) - template + /// @see vec packSnorm(vec const & v) + template GLM_FUNC_DECL vec unpackSnorm(vec const & v); /// Convert each component of the normalized floating-point vector into unsigned integer values. diff --git a/glm/gtc/packing.inl b/glm/gtc/packing.inl index 1a4e649a..5690b039 100644 --- a/glm/gtc/packing.inl +++ b/glm/gtc/packing.inl @@ -271,12 +271,12 @@ namespace detail uint32 pack; }; - template class vecType> + template struct compute_half {}; - template - struct compute_half<1, P, vec> + template + struct compute_half<1, P> { GLM_FUNC_QUALIFIER static vec<1, uint16, P> pack(vec<1, float, P> const & v) { @@ -294,8 +294,8 @@ namespace detail } }; - template - struct compute_half<2, P, vec> + template + struct compute_half<2, P> { GLM_FUNC_QUALIFIER static vec<2, uint16, P> pack(vec<2, float, P> const & v) { @@ -313,8 +313,8 @@ namespace detail } }; - template - struct compute_half<3, P, vec> + template + struct compute_half<3, P> { GLM_FUNC_QUALIFIER static vec<3, uint16, P> pack(vec<3, float, P> const & v) { @@ -332,8 +332,8 @@ namespace detail } }; - template - struct compute_half<4, P, vec> + template + struct compute_half<4, P> { GLM_FUNC_QUALIFIER static vec<4, uint16, P> pack(vec<4, float, P> const & v) { @@ -641,7 +641,7 @@ namespace detail } // Based on Brian Karis http://graphicrants.blogspot.fr/2009/04/rgbm-color-encoding.html - template + template GLM_FUNC_QUALIFIER vec<4, T, P> packRGBM(vec<3, T, P> const & rgb) { vec<3, T, P> const Color(rgb * static_cast(1.0 / 6.0)); @@ -650,25 +650,25 @@ namespace detail return vec<4, T, P>(Color / Alpha, Alpha); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> unpackRGBM(vec<4, T, P> const & rgbm) { return vec<3, T, P>(rgbm.x, rgbm.y, rgbm.z) * rgbm.w * static_cast(6); } - template class vecType> - GLM_FUNC_QUALIFIER vecType packHalf(vecType const & v) + template + GLM_FUNC_QUALIFIER vec packHalf(vec const & v) { - return detail::compute_half::pack(v); + return detail::compute_half::pack(v); } - template class vecType> - GLM_FUNC_QUALIFIER vecType unpackHalf(vecType const & v) + template + GLM_FUNC_QUALIFIER vec unpackHalf(vec const & v) { - return detail::compute_half::unpack(v); + return detail::compute_half::unpack(v); } - template + template GLM_FUNC_QUALIFIER vec packUnorm(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "uintType must be an integer type"); @@ -677,7 +677,7 @@ namespace detail return vec(round(clamp(v, static_cast(0), static_cast(1)) * static_cast(std::numeric_limits::max()))); } - template + template GLM_FUNC_QUALIFIER vec unpackUnorm(vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "uintType must be an integer type"); @@ -686,7 +686,7 @@ namespace detail return vec(v) * (static_cast(1) / static_cast(std::numeric_limits::max())); } - template + template GLM_FUNC_QUALIFIER vec packSnorm(vec const & v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "uintType must be an integer type"); @@ -695,7 +695,7 @@ namespace detail return vec(round(clamp(v , static_cast(-1), static_cast(1)) * static_cast(std::numeric_limits::max()))); } - template + template GLM_FUNC_QUALIFIER vec unpackSnorm(vec const & v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "uintType must be an integer type"); diff --git a/glm/gtc/quaternion.hpp b/glm/gtc/quaternion.hpp index 30e4275e..694f0d2e 100644 --- a/glm/gtc/quaternion.hpp +++ b/glm/gtc/quaternion.hpp @@ -29,7 +29,7 @@ namespace glm /// @addtogroup gtc_quaternion /// @{ - template + template struct tquat { // -- Implementation detail -- @@ -79,7 +79,7 @@ namespace glm GLM_FUNC_DECL GLM_CONSTEXPR tquat() GLM_DEFAULT; GLM_FUNC_DECL GLM_CONSTEXPR tquat(tquat const& q) GLM_DEFAULT; - template + template GLM_FUNC_DECL GLM_CONSTEXPR tquat(tquat const& q); // -- Explicit basic constructors -- @@ -89,7 +89,7 @@ namespace glm // -- Conversion constructors -- - template + template GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tquat(tquat const& q); /// Explicit conversion operators @@ -131,47 +131,47 @@ namespace glm // -- Unary bit operators -- - template + template GLM_FUNC_DECL tquat operator+(tquat const& q); - template + template GLM_FUNC_DECL tquat operator-(tquat const& q); // -- Binary operators -- - template + template GLM_FUNC_DECL tquat operator+(tquat const & q, tquat const & p); - template + template GLM_FUNC_DECL tquat operator*(tquat const & q, tquat const & p); - template + template GLM_FUNC_DECL vec<3, T, P> operator*(tquat const & q, vec<3, T, P> const & v); - template + template GLM_FUNC_DECL vec<3, T, P> operator*(vec<3, T, P> const & v, tquat const & q); - template + template GLM_FUNC_DECL vec<4, T, P> operator*(tquat const & q, vec<4, T, P> const & v); - template + template GLM_FUNC_DECL vec<4, T, P> operator*(vec<4, T, P> const & v, tquat const & q); - template + template GLM_FUNC_DECL tquat operator*(tquat const & q, T const & s); - template + template GLM_FUNC_DECL tquat operator*(T const & s, tquat const & q); - template + template GLM_FUNC_DECL tquat operator/(tquat const & q, T const & s); // -- Boolean operators -- - template + template GLM_FUNC_DECL bool operator==(tquat const & q1, tquat const & q2); - template + template GLM_FUNC_DECL bool operator!=(tquat const & q1, tquat const & q2); /// Returns the length of the quaternion. @@ -179,7 +179,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL T length(tquat const & q); /// Returns the normalized quaternion. @@ -187,7 +187,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL tquat normalize(tquat const & q); /// Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ... @@ -195,7 +195,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL T dot(tquat const & x, tquat const & y); /// Spherical linear interpolation of two quaternions. @@ -209,7 +209,7 @@ namespace glm /// /// @see - slerp(tquat const & x, tquat const & y, T const & a) /// @see gtc_quaternion - template + template GLM_FUNC_DECL tquat mix(tquat const & x, tquat const & y, T a); /// Linear interpolation of two quaternions. @@ -221,7 +221,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL tquat lerp(tquat const & x, tquat const & y, T a); /// Spherical linear interpolation of two quaternions. @@ -233,7 +233,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL tquat slerp(tquat const & x, tquat const & y, T a); /// Returns the q conjugate. @@ -241,7 +241,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL tquat conjugate(tquat const & q); /// Returns the q inverse. @@ -249,7 +249,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL tquat inverse(tquat const & q); /// Rotates a quaternion from a vector of 3 components axis and an angle. @@ -260,7 +260,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL tquat rotate(tquat const & q, T const & angle, vec<3, T, P> const & axis); /// Returns euler angles, pitch as x, yaw as y, roll as z. @@ -269,7 +269,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL vec<3, T, P> eulerAngles(tquat const & x); /// Returns roll value of euler angles expressed in radians. @@ -277,7 +277,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL T roll(tquat const& x); /// Returns pitch value of euler angles expressed in radians. @@ -285,7 +285,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL T pitch(tquat const& x); /// Returns yaw value of euler angles expressed in radians. @@ -293,7 +293,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL T yaw(tquat const& x); /// Converts a quaternion to a 3 * 3 matrix. @@ -301,7 +301,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL mat<3, 3, T, P> mat3_cast(tquat const& x); /// Converts a quaternion to a 4 * 4 matrix. @@ -309,7 +309,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL mat<4, 4, T, P> mat4_cast(tquat const& x); /// Converts a 3 * 3 matrix to a quaternion. @@ -317,7 +317,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL tquat quat_cast(mat<3, 3, T, P> const& x); /// Converts a 4 * 4 matrix to a quaternion. @@ -325,7 +325,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL tquat quat_cast(mat<4, 4, T, P> const& x); /// Returns the quaternion rotation angle. @@ -333,7 +333,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL T angle(tquat const& x); /// Returns the q rotation axis. @@ -341,7 +341,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL vec<3, T, P> axis(tquat const& x); /// Build a quaternion from an angle and a normalized axis. @@ -351,7 +351,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL tquat angleAxis(T const& angle, vec<3, T, P> const& axis); /// Returns the component-wise comparison result of x < y. @@ -359,7 +359,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL vec<4, bool, P> lessThan(tquat const& x, tquat const& y); /// Returns the component-wise comparison of result x <= y. @@ -367,7 +367,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL vec<4, bool, P> lessThanEqual(tquat const& x, tquat const& y); /// Returns the component-wise comparison of result x > y. @@ -375,7 +375,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL vec<4, bool, P> greaterThan(tquat const& x, tquat const& y); /// Returns the component-wise comparison of result x >= y. @@ -383,7 +383,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL vec<4, bool, P> greaterThanEqual(tquat const& x, tquat const& y); /// Returns the component-wise comparison of result x == y. @@ -391,7 +391,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL vec<4, bool, P> equal(tquat const& x, tquat const& y); /// Returns the component-wise comparison of result x != y. @@ -399,7 +399,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL vec<4, bool, P> notEqual(tquat const& x, tquat const& y); /// Returns true if x holds a NaN (not a number) @@ -413,7 +413,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL vec<4, bool, P> isnan(tquat const& x); /// Returns true if x holds a positive infinity or negative @@ -425,7 +425,7 @@ namespace glm /// @tparam T Floating-point scalar types. /// /// @see gtc_quaternion - template + template GLM_FUNC_DECL vec<4, bool, P> isinf(tquat const& x); /// @} diff --git a/glm/gtc/quaternion.inl b/glm/gtc/quaternion.inl index 9f2fdae4..b96a5cf7 100644 --- a/glm/gtc/quaternion.inl +++ b/glm/gtc/quaternion.inl @@ -11,7 +11,7 @@ namespace glm{ namespace detail { - template + template struct compute_dot, T, Aligned> { static GLM_FUNC_QUALIFIER T call(tquat const& a, tquat const& b) @@ -21,7 +21,7 @@ namespace detail } }; - template + template struct compute_quat_add { static tquat call(tquat const& q, tquat const& p) @@ -30,7 +30,7 @@ namespace detail } }; - template + template struct compute_quat_sub { static tquat call(tquat const& q, tquat const& p) @@ -39,7 +39,7 @@ namespace detail } }; - template + template struct compute_quat_mul_scalar { static tquat call(tquat const& q, T s) @@ -48,7 +48,7 @@ namespace detail } }; - template + template struct compute_quat_div_scalar { static tquat call(tquat const& q, T s) @@ -57,7 +57,7 @@ namespace detail } }; - template + template struct compute_quat_mul_vec4 { static vec<4, T, P> call(tquat const & q, vec<4, T, P> const & v) @@ -69,14 +69,14 @@ namespace detail // -- Component accesses -- - template + template GLM_FUNC_QUALIFIER T & tquat::operator[](typename tquat::length_type i) { assert(i >= 0 && i < this->length()); return (&x)[i]; } - template + template GLM_FUNC_QUALIFIER T const & tquat::operator[](typename tquat::length_type i) const { assert(i >= 0 && i < this->length()); @@ -86,40 +86,40 @@ namespace detail // -- Implicit basic constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat::tquat() {} # endif # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat::tquat(tquat const & q) : x(q.x), y(q.y), z(q.z), w(q.w) {} # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat::tquat(tquat const& q) : x(q.x), y(q.y), z(q.z), w(q.w) {} // -- Explicit basic constructors -- - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat::tquat(T s, vec<3, T, P> const& v) : x(v.x), y(v.y), z(v.z), w(s) {} - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat::tquat(T _w, T _x, T _y, T _z) : x(_x), y(_y), z(_z), w(_w) {} // -- Conversion constructors -- - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat::tquat(tquat const& q) : x(static_cast(q.x)) , y(static_cast(q.y)) @@ -145,7 +145,7 @@ namespace detail // this->z = c.x * c.y * s.z - s.x * s.y * c.z; //} - template + template GLM_FUNC_QUALIFIER tquat::tquat(vec<3, T, P> const& u, vec<3, T, P> const& v) { vec<3, T, P> const LocalW(cross(u, v)); @@ -155,7 +155,7 @@ namespace detail *this = normalize(q); } - template + template GLM_FUNC_QUALIFIER tquat::tquat(vec<3, T, P> const& eulerAngle) { vec<3, T, P> c = glm::cos(eulerAngle * T(0.5)); @@ -167,39 +167,39 @@ namespace detail this->z = c.x * c.y * s.z - s.x * s.y * c.z; } - template + template GLM_FUNC_QUALIFIER tquat::tquat(mat<3, 3, T, P> const& m) { *this = quat_cast(m); } - template + template GLM_FUNC_QUALIFIER tquat::tquat(mat<4, 4, T, P> const& m) { *this = quat_cast(m); } # if GLM_HAS_EXPLICIT_CONVERSION_OPERATORS - template + template GLM_FUNC_QUALIFIER tquat::operator mat<3, 3, T, P>() { return mat3_cast(*this); } - template + template GLM_FUNC_QUALIFIER tquat::operator mat<4, 4, T, P>() { return mat4_cast(*this); } # endif//GLM_HAS_EXPLICIT_CONVERSION_OPERATORS - template + template GLM_FUNC_QUALIFIER tquat conjugate(tquat const& q) { return tquat(q.w, -q.x, -q.y, -q.z); } - template + template GLM_FUNC_QUALIFIER tquat inverse(tquat const & q) { return conjugate(q) / dot(q, q); @@ -208,7 +208,7 @@ namespace detail // -- Unary arithmetic operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER tquat & tquat::operator=(tquat const & q) { this->w = q.w; @@ -219,7 +219,7 @@ namespace detail } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template + template template GLM_FUNC_QUALIFIER tquat & tquat::operator=(tquat const & q) { @@ -230,21 +230,21 @@ namespace detail return *this; } - template + template template GLM_FUNC_QUALIFIER tquat & tquat::operator+=(tquat const& q) { return (*this = detail::compute_quat_add::value>::call(*this, tquat(q))); } - template + template template GLM_FUNC_QUALIFIER tquat & tquat::operator-=(tquat const& q) { return (*this = detail::compute_quat_sub::value>::call(*this, tquat(q))); } - template + template template GLM_FUNC_QUALIFIER tquat & tquat::operator*=(tquat const & r) { @@ -258,14 +258,14 @@ namespace detail return *this; } - template + template template GLM_FUNC_QUALIFIER tquat & tquat::operator*=(U s) { return (*this = detail::compute_quat_mul_scalar::value>::call(*this, static_cast(s))); } - template + template template GLM_FUNC_QUALIFIER tquat & tquat::operator/=(U s) { @@ -274,13 +274,13 @@ namespace detail // -- Unary bit operators -- - template + template GLM_FUNC_QUALIFIER tquat operator+(tquat const & q) { return q; } - template + template GLM_FUNC_QUALIFIER tquat operator-(tquat const & q) { return tquat(-q.w, -q.x, -q.y, -q.z); @@ -288,19 +288,19 @@ namespace detail // -- Binary operators -- - template + template GLM_FUNC_QUALIFIER tquat operator+(tquat const & q, tquat const & p) { return tquat(q) += p; } - template + template GLM_FUNC_QUALIFIER tquat operator*(tquat const & q, tquat const & p) { return tquat(q) *= p; } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator*(tquat const & q, vec<3, T, P> const & v) { vec<3, T, P> const QuatVector(q.x, q.y, q.z); @@ -310,38 +310,38 @@ namespace detail return v + ((uv * q.w) + uuv) * static_cast(2); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> operator*(vec<3, T, P> const & v, tquat const & q) { return glm::inverse(q) * v; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator*(tquat const& q, vec<4, T, P> const& v) { return detail::compute_quat_mul_vec4::value>::call(q, v); } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator*(vec<4, T, P> const & v, tquat const & q) { return glm::inverse(q) * v; } - template + template GLM_FUNC_QUALIFIER tquat operator*(tquat const & q, T const & s) { return tquat( q.w * s, q.x * s, q.y * s, q.z * s); } - template + template GLM_FUNC_QUALIFIER tquat operator*(T const & s, tquat const & q) { return q * s; } - template + template GLM_FUNC_QUALIFIER tquat operator/(tquat const & q, T const & s) { return tquat( @@ -350,13 +350,13 @@ namespace detail // -- Boolean operators -- - template + template GLM_FUNC_QUALIFIER bool operator==(tquat const & q1, tquat const & q2) { return all(epsilonEqual(q1, q2, epsilon())); } - template + template GLM_FUNC_QUALIFIER bool operator!=(tquat const & q1, tquat const & q2) { return any(epsilonNotEqual(q1, q2, epsilon())); @@ -364,13 +364,13 @@ namespace detail // -- Operations -- - template + template GLM_FUNC_QUALIFIER T length(tquat const & q) { return glm::sqrt(dot(q, q)); } - template + template GLM_FUNC_QUALIFIER tquat normalize(tquat const & q) { T len = length(q); @@ -380,7 +380,7 @@ namespace detail return tquat(q.w * oneOverLen, q.x * oneOverLen, q.y * oneOverLen, q.z * oneOverLen); } - template + template GLM_FUNC_QUALIFIER tquat cross(tquat const & q1, tquat const & q2) { return tquat( @@ -391,7 +391,7 @@ namespace detail } /* // (x * sin(1 - a) * angle / sin(angle)) + (y * sin(a) * angle / sin(angle)) - template + template GLM_FUNC_QUALIFIER tquat mix(tquat const & x, tquat const & y, T const & a) { if(a <= T(0)) return x; @@ -428,7 +428,7 @@ namespace detail k0 * x.z + k1 * y2.z); } - template + template GLM_FUNC_QUALIFIER tquat mix2 ( tquat const & x, @@ -466,7 +466,7 @@ namespace detail } */ - template + template GLM_FUNC_QUALIFIER tquat mix(tquat const & x, tquat const & y, T a) { T cosTheta = dot(x, y); @@ -489,7 +489,7 @@ namespace detail } } - template + template GLM_FUNC_QUALIFIER tquat lerp(tquat const & x, tquat const & y, T a) { // Lerp is only defined in [0, 1] @@ -499,7 +499,7 @@ namespace detail return x * (T(1) - a) + (y * a); } - template + template GLM_FUNC_QUALIFIER tquat slerp(tquat const & x, tquat const & y, T a) { tquat z = y; @@ -532,7 +532,7 @@ namespace detail } } - template + template GLM_FUNC_QUALIFIER tquat rotate(tquat const & q, T const & angle, vec<3, T, P> const & v) { vec<3, T, P> Tmp = v; @@ -554,19 +554,19 @@ namespace detail //return gtc::quaternion::cross(q, tquat(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin)); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> eulerAngles(tquat const & x) { return vec<3, T, P>(pitch(x), yaw(x), roll(x)); } - template + template GLM_FUNC_QUALIFIER T roll(tquat const & q) { return static_cast(atan(static_cast(2) * (q.x * q.y + q.w * q.z), q.w * q.w + q.x * q.x - q.y * q.y - q.z * q.z)); } - template + template GLM_FUNC_QUALIFIER T pitch(tquat const & q) { //return T(atan(T(2) * (q.y * q.z + q.w * q.x), q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z)); @@ -579,13 +579,13 @@ namespace detail return static_cast(atan(y,x)); } - template + template GLM_FUNC_QUALIFIER T yaw(tquat const & q) { return asin(clamp(static_cast(-2) * (q.x * q.z - q.w * q.y), static_cast(-1), static_cast(1))); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> mat3_cast(tquat const & q) { mat<3, 3, T, P> Result(T(1)); @@ -613,13 +613,13 @@ namespace detail return Result; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> mat4_cast(tquat const & q) { return mat<4, 4, T, P>(mat3_cast(q)); } - template + template GLM_FUNC_QUALIFIER tquat quat_cast(mat<3, 3, T, P> const & m) { T fourXSquaredMinus1 = m[0][0] - m[1][1] - m[2][2]; @@ -683,19 +683,19 @@ namespace detail return Result; } - template + template GLM_FUNC_QUALIFIER tquat quat_cast(mat<4, 4, T, P> const & m4) { return quat_cast(mat<3, 3, T, P>(m4)); } - template + template GLM_FUNC_QUALIFIER T angle(tquat const & x) { return acos(x.w) * static_cast(2); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> axis(tquat const & x) { T tmp1 = static_cast(1) - x.w * x.w; @@ -705,7 +705,7 @@ namespace detail return vec<3, T, P>(x.x * tmp2, x.y * tmp2, x.z * tmp2); } - template + template GLM_FUNC_QUALIFIER tquat angleAxis(T const & angle, vec<3, T, P> const & v) { tquat Result; @@ -720,7 +720,7 @@ namespace detail return Result; } - template + template GLM_FUNC_QUALIFIER vec<4, bool, P> lessThan(tquat const & x, tquat const & y) { vec<4, bool, P> Result; @@ -729,7 +729,7 @@ namespace detail return Result; } - template + template GLM_FUNC_QUALIFIER vec<4, bool, P> lessThanEqual(tquat const & x, tquat const & y) { vec<4, bool, P> Result; @@ -738,7 +738,7 @@ namespace detail return Result; } - template + template GLM_FUNC_QUALIFIER vec<4, bool, P> greaterThan(tquat const & x, tquat const & y) { vec<4, bool, P> Result; @@ -747,7 +747,7 @@ namespace detail return Result; } - template + template GLM_FUNC_QUALIFIER vec<4, bool, P> greaterThanEqual(tquat const & x, tquat const & y) { vec<4, bool, P> Result; @@ -756,7 +756,7 @@ namespace detail return Result; } - template + template GLM_FUNC_QUALIFIER vec<4, bool, P> equal(tquat const& x, tquat const& y) { vec<4, bool, P> Result; @@ -765,7 +765,7 @@ namespace detail return Result; } - template + template GLM_FUNC_QUALIFIER vec<4, bool, P> notEqual(tquat const& x, tquat const& y) { vec<4, bool, P> Result; @@ -774,7 +774,7 @@ namespace detail return Result; } - template + template GLM_FUNC_QUALIFIER vec<4, bool, P> isnan(tquat const& q) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isnan' only accept floating-point inputs"); @@ -782,7 +782,7 @@ namespace detail return vec<4, bool, P>(isnan(q.x), isnan(q.y), isnan(q.z), isnan(q.w)); } - template + template GLM_FUNC_QUALIFIER vec<4, bool, P> isinf(tquat const& q) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isinf' only accept floating-point inputs"); diff --git a/glm/gtc/quaternion_simd.inl b/glm/gtc/quaternion_simd.inl index 4f86fc5b..262e0235 100644 --- a/glm/gtc/quaternion_simd.inl +++ b/glm/gtc/quaternion_simd.inl @@ -7,7 +7,7 @@ namespace glm{ namespace detail { /* - template + template struct compute_quat_mul { static tquat call(tquat const& q1, tquat const& q2) @@ -61,7 +61,7 @@ namespace detail }; */ - template + template struct compute_dot, float, true> { static GLM_FUNC_QUALIFIER float call(tquat const& x, tquat const& y) @@ -70,7 +70,7 @@ namespace detail } }; - template + template struct compute_quat_add { static tquat call(tquat const& q, tquat const& p) @@ -82,7 +82,7 @@ namespace detail }; # if GLM_ARCH & GLM_ARCH_AVX_BIT - template + template struct compute_quat_add { static tquat call(tquat const & a, tquat const & b) @@ -94,7 +94,7 @@ namespace detail }; # endif - template + template struct compute_quat_sub { static tquat call(tquat const& q, tquat const& p) @@ -106,7 +106,7 @@ namespace detail }; # if GLM_ARCH & GLM_ARCH_AVX_BIT - template + template struct compute_quat_sub { static tquat call(tquat const & a, tquat const & b) @@ -118,7 +118,7 @@ namespace detail }; # endif - template + template struct compute_quat_mul_scalar { static tquat call(tquat const& q, float s) @@ -130,7 +130,7 @@ namespace detail }; # if GLM_ARCH & GLM_ARCH_AVX_BIT - template + template struct compute_quat_mul_scalar { static tquat call(tquat const& q, double s) @@ -142,7 +142,7 @@ namespace detail }; # endif - template + template struct compute_quat_div_scalar { static tquat call(tquat const& q, float s) @@ -154,7 +154,7 @@ namespace detail }; # if GLM_ARCH & GLM_ARCH_AVX_BIT - template + template struct compute_quat_div_scalar { static tquat call(tquat const& q, double s) @@ -166,7 +166,7 @@ namespace detail }; # endif - template + template struct compute_quat_mul_vec4 { static vec<4, float, P> call(tquat const& q, vec<4, float, P> const& v) diff --git a/glm/gtc/random.hpp b/glm/gtc/random.hpp index 4080f430..391dd929 100644 --- a/glm/gtc/random.hpp +++ b/glm/gtc/random.hpp @@ -40,9 +40,9 @@ namespace glm /// @param Min Minimum value included in the sampling /// @param Max Maximum value included in the sampling /// @tparam T Value type. Currently supported: float or double. - /// @tparam vecType A vertor type: tvec1, tvec2, tvec3, tvec4 or compatible + /// /// @see gtc_random - template + template GLM_FUNC_DECL vec linearRand(vec const& Min, vec const& Max); /// Generate random numbers in the interval [Min, Max], according a gaussian distribution diff --git a/glm/gtc/random.inl b/glm/gtc/random.inl index b6385189..c1cb84de 100644 --- a/glm/gtc/random.inl +++ b/glm/gtc/random.inl @@ -12,13 +12,13 @@ namespace glm{ namespace detail { - template + template struct compute_rand { GLM_FUNC_QUALIFIER static vec call(); }; - template + template struct compute_rand<1, uint8, P> { GLM_FUNC_QUALIFIER static vec<1, uint8, P> call() @@ -28,7 +28,7 @@ namespace detail } }; - template + template struct compute_rand<2, uint8, P> { GLM_FUNC_QUALIFIER static vec<2, uint8, P> call() @@ -39,7 +39,7 @@ namespace detail } }; - template + template struct compute_rand<3, uint8, P> { GLM_FUNC_QUALIFIER static vec<3, uint8, P> call() @@ -51,7 +51,7 @@ namespace detail } }; - template + template struct compute_rand<4, uint8, P> { GLM_FUNC_QUALIFIER static vec<4, uint8, P> call() @@ -64,7 +64,7 @@ namespace detail } }; - template + template struct compute_rand { GLM_FUNC_QUALIFIER static vec call() @@ -75,7 +75,7 @@ namespace detail } }; - template + template struct compute_rand { GLM_FUNC_QUALIFIER static vec call() @@ -86,7 +86,7 @@ namespace detail } }; - template + template struct compute_rand { GLM_FUNC_QUALIFIER static vec call() @@ -97,13 +97,13 @@ namespace detail } }; - template + template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max); }; - template + template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) @@ -112,7 +112,7 @@ namespace detail } }; - template + template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) @@ -121,7 +121,7 @@ namespace detail } }; - template + template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) @@ -130,7 +130,7 @@ namespace detail } }; - template + template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) @@ -139,7 +139,7 @@ namespace detail } }; - template + template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const & Min, vec const& Max) @@ -148,7 +148,7 @@ namespace detail } }; - template + template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) @@ -157,7 +157,7 @@ namespace detail } }; - template + template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) @@ -166,7 +166,7 @@ namespace detail } }; - template + template struct compute_linearRand { GLM_FUNC_QUALIFIER static vec call(vec const& Min, vec const& Max) @@ -265,7 +265,7 @@ namespace detail vec<1, genType, highp>(Max)).x; } - template + template GLM_FUNC_QUALIFIER vec linearRand(vec const & Min, vec const& Max) { return detail::compute_linearRand::call(Min, Max); @@ -287,7 +287,7 @@ namespace detail return x2 * Deviation * Deviation * sqrt((genType(-2) * log(w)) / w) + Mean; } - template + template GLM_FUNC_QUALIFIER vec gaussRand(vec const& Mean, vec const& Deviation) { return detail::functor2::call(gaussRand, Mean, Deviation); diff --git a/glm/gtc/reciprocal.inl b/glm/gtc/reciprocal.inl index 1c667ad3..8b7a8878 100644 --- a/glm/gtc/reciprocal.inl +++ b/glm/gtc/reciprocal.inl @@ -14,8 +14,8 @@ namespace glm return genType(1) / glm::cos(angle); } - template class vecType> - GLM_FUNC_QUALIFIER vecType sec(vecType const & x) + template + GLM_FUNC_QUALIFIER vec sec(vec const & x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'sec' only accept floating-point inputs"); return detail::functor1::call(sec, x); @@ -29,8 +29,8 @@ namespace glm return genType(1) / glm::sin(angle); } - template class vecType> - GLM_FUNC_QUALIFIER vecType csc(vecType const & x) + template + GLM_FUNC_QUALIFIER vec csc(vec const & x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'csc' only accept floating-point inputs"); return detail::functor1::call(csc, x); @@ -46,8 +46,8 @@ namespace glm return glm::tan(pi_over_2 - angle); } - template class vecType> - GLM_FUNC_QUALIFIER vecType cot(vecType const & x) + template + GLM_FUNC_QUALIFIER vec cot(vec const & x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'cot' only accept floating-point inputs"); return detail::functor1::call(cot, x); @@ -61,8 +61,8 @@ namespace glm return acos(genType(1) / x); } - template class vecType> - GLM_FUNC_QUALIFIER vecType asec(vecType const & x) + template + GLM_FUNC_QUALIFIER vec asec(vec const & x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'asec' only accept floating-point inputs"); return detail::functor1::call(asec, x); @@ -76,8 +76,8 @@ namespace glm return asin(genType(1) / x); } - template class vecType> - GLM_FUNC_QUALIFIER vecType acsc(vecType const & x) + template + GLM_FUNC_QUALIFIER vec acsc(vec const & x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'acsc' only accept floating-point inputs"); return detail::functor1::call(acsc, x); @@ -93,8 +93,8 @@ namespace glm return pi_over_2 - atan(x); } - template class vecType> - GLM_FUNC_QUALIFIER vecType acot(vecType const & x) + template + GLM_FUNC_QUALIFIER vec acot(vec const & x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'acot' only accept floating-point inputs"); return detail::functor1::call(acot, x); @@ -108,8 +108,8 @@ namespace glm return genType(1) / glm::cosh(angle); } - template class vecType> - GLM_FUNC_QUALIFIER vecType sech(vecType const & x) + template + GLM_FUNC_QUALIFIER vec sech(vec const & x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'sech' only accept floating-point inputs"); return detail::functor1::call(sech, x); @@ -123,8 +123,8 @@ namespace glm return genType(1) / glm::sinh(angle); } - template class vecType> - GLM_FUNC_QUALIFIER vecType csch(vecType const & x) + template + GLM_FUNC_QUALIFIER vec csch(vec const & x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'csch' only accept floating-point inputs"); return detail::functor1::call(csch, x); @@ -138,8 +138,8 @@ namespace glm return glm::cosh(angle) / glm::sinh(angle); } - template class vecType> - GLM_FUNC_QUALIFIER vecType coth(vecType const & x) + template + GLM_FUNC_QUALIFIER vec coth(vec const & x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'coth' only accept floating-point inputs"); return detail::functor1::call(coth, x); @@ -153,8 +153,8 @@ namespace glm return acosh(genType(1) / x); } - template class vecType> - GLM_FUNC_QUALIFIER vecType asech(vecType const & x) + template + GLM_FUNC_QUALIFIER vec asech(vec const & x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'asech' only accept floating-point inputs"); return detail::functor1::call(asech, x); @@ -168,8 +168,8 @@ namespace glm return acsch(genType(1) / x); } - template class vecType> - GLM_FUNC_QUALIFIER vecType acsch(vecType const & x) + template + GLM_FUNC_QUALIFIER vec acsch(vec const & x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'acsch' only accept floating-point inputs"); return detail::functor1::call(acsch, x); @@ -183,8 +183,8 @@ namespace glm return atanh(genType(1) / x); } - template class vecType> - GLM_FUNC_QUALIFIER vecType acoth(vecType const & x) + template + GLM_FUNC_QUALIFIER vec acoth(vec const & x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'acoth' only accept floating-point inputs"); return detail::functor1::call(acoth, x); diff --git a/glm/gtc/round.hpp b/glm/gtc/round.hpp index 8ca22bfd..6b5b6e20 100644 --- a/glm/gtc/round.hpp +++ b/glm/gtc/round.hpp @@ -15,7 +15,7 @@ // Dependencies #include "../detail/setup.hpp" -#include "../detail/precision.hpp" +#include "../detail/qualifier.hpp" #include "../detail/_vectorize.hpp" #include "../vector_relational.hpp" #include "../common.hpp" @@ -39,7 +39,7 @@ namespace glm /// Return true if the value is a power of two number. /// /// @see gtc_round - template + template GLM_FUNC_DECL vec isPowerOfTwo(vec const& value); /// Return the power of two number which value is just higher the input value, @@ -53,7 +53,7 @@ namespace glm /// round up to a power of two. /// /// @see gtc_round - template + template GLM_FUNC_DECL vec ceilPowerOfTwo(vec const& value); /// Return the power of two number which value is just lower the input value, @@ -67,7 +67,7 @@ namespace glm /// round down to a power of two. /// /// @see gtc_round - template + template GLM_FUNC_DECL vec floorPowerOfTwo(vec const& value); /// Return the power of two number which value is the closet to the input value. @@ -79,7 +79,7 @@ namespace glm /// Return the power of two number which value is the closet to the input value. /// /// @see gtc_round - template + template GLM_FUNC_DECL vec roundPowerOfTwo(vec const& value); /// Return true if the 'Value' is a multiple of 'Multiple'. @@ -91,13 +91,13 @@ namespace glm /// Return true if the 'Value' is a multiple of 'Multiple'. /// /// @see gtc_round - template + template GLM_FUNC_DECL vec isMultiple(vec const& Value, T Multiple); /// Return true if the 'Value' is a multiple of 'Multiple'. /// /// @see gtc_round - template + template GLM_FUNC_DECL vec isMultiple(vec const& Value, vec const& Multiple); /// Higher multiple number of Source. @@ -115,7 +115,7 @@ namespace glm /// @param Multiple Must be a null or positive value /// /// @see gtc_round - template + template GLM_FUNC_DECL vec ceilMultiple(vec const & Source, vec const& Multiple); /// Lower multiple number of Source. @@ -133,7 +133,7 @@ namespace glm /// @param Multiple Must be a null or positive value /// /// @see gtc_round - template + template GLM_FUNC_DECL vec floorMultiple(vec const& Source, vec const& Multiple); /// Lower multiple number of Source. @@ -151,7 +151,7 @@ namespace glm /// @param Multiple Must be a null or positive value /// /// @see gtc_round - template + template GLM_FUNC_DECL vec roundMultiple(vec const& Source, vec const& Multiple); /// @} diff --git a/glm/gtc/round.inl b/glm/gtc/round.inl index 5cfae57d..5fda25fd 100644 --- a/glm/gtc/round.inl +++ b/glm/gtc/round.inl @@ -6,7 +6,7 @@ namespace glm{ namespace detail { - template + template struct compute_ceilShift { GLM_FUNC_QUALIFIER static vec call(vec const& v, T) @@ -15,7 +15,7 @@ namespace detail } }; - template + template struct compute_ceilShift { GLM_FUNC_QUALIFIER static vec call(vec const& v, T Shift) @@ -24,7 +24,7 @@ namespace detail } }; - template + template struct compute_ceilPowerOfTwo { GLM_FUNC_QUALIFIER static vec call(vec const& x) @@ -46,7 +46,7 @@ namespace detail } }; - template + template struct compute_ceilPowerOfTwo { GLM_FUNC_QUALIFIER static vec call(vec const& x) @@ -219,7 +219,7 @@ namespace detail return !(Result & (Result - 1)); } - template + template GLM_FUNC_QUALIFIER vec isPowerOfTwo(vec const & Value) { vec const Result(abs(Value)); @@ -235,7 +235,7 @@ namespace detail return detail::compute_ceilPowerOfTwo<1, genType, defaultp, std::numeric_limits::is_signed>::call(vec<1, genType, defaultp>(value)).x; } - template + template GLM_FUNC_QUALIFIER vec ceilPowerOfTwo(vec const& v) { return detail::compute_ceilPowerOfTwo::is_signed>::call(v); @@ -250,7 +250,7 @@ namespace detail return isPowerOfTwo(value) ? value : static_cast(1) << findMSB(value); } - template + template GLM_FUNC_QUALIFIER vec floorPowerOfTwo(vec const & v) { return detail::functor1::call(floorPowerOfTwo, v); @@ -270,7 +270,7 @@ namespace detail return (next - value) < (value - prev) ? next : prev; } - template + template GLM_FUNC_QUALIFIER vec roundPowerOfTwo(vec const & v) { return detail::functor1::call(roundPowerOfTwo, v); @@ -285,13 +285,13 @@ namespace detail return isMultiple(vec<1, genType>(Value), vec<1, genType>(Multiple)).x; } - template + template GLM_FUNC_QUALIFIER vec isMultiple(vec const & Value, T Multiple) { return (Value % Multiple) == vec(0); } - template + template GLM_FUNC_QUALIFIER vec isMultiple(vec const& Value, vec const& Multiple) { return (Value % Multiple) == vec(0); @@ -306,7 +306,7 @@ namespace detail return detail::compute_ceilMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple); } - template + template GLM_FUNC_QUALIFIER vec ceilMultiple(vec const& Source, vec const& Multiple) { return detail::functor2::call(ceilMultiple, Source, Multiple); @@ -321,7 +321,7 @@ namespace detail return detail::compute_floorMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple); } - template + template GLM_FUNC_QUALIFIER vec floorMultiple(vec const& Source, vec const& Multiple) { return detail::functor2::call(floorMultiple, Source, Multiple); @@ -336,7 +336,7 @@ namespace detail return detail::compute_roundMultiple::is_iec559, std::numeric_limits::is_signed>::call(Source, Multiple); } - template + template GLM_FUNC_QUALIFIER vec roundMultiple(vec const& Source, vec const& Multiple) { return detail::functor2::call(roundMultiple, Source, Multiple); diff --git a/glm/gtc/type_aligned.hpp b/glm/gtc/type_aligned.hpp index fb81498a..ee6f8dd8 100644 --- a/glm/gtc/type_aligned.hpp +++ b/glm/gtc/type_aligned.hpp @@ -64,170 +64,170 @@ namespace glm // -- *vec2 -- - /// 2 components vector of high single-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of high single-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. typedef vec<2, float, aligned_highp> aligned_highp_vec2; - /// 2 components vector of medium single-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of medium single-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. typedef vec<2, float, aligned_mediump> aligned_mediump_vec2; - /// 2 components vector of low single-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of low single-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. typedef vec<2, float, aligned_lowp> aligned_lowp_vec2; - /// 2 components vector of high double-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of high double-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. typedef vec<2, double, aligned_highp> aligned_highp_dvec2; - /// 2 components vector of medium double-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of medium double-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. typedef vec<2, double, aligned_mediump> aligned_mediump_dvec2; - /// 2 components vector of low double-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of low double-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. typedef vec<2, double, aligned_lowp> aligned_lowp_dvec2; - /// 2 components vector of high precision signed integer numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of high qualifier signed integer numbers. + /// There is no guarantee on the actual qualifier. typedef vec<2, int, aligned_highp> aligned_highp_ivec2; - /// 2 components vector of medium precision signed integer numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of medium qualifier signed integer numbers. + /// There is no guarantee on the actual qualifier. typedef vec<2, int, aligned_mediump> aligned_mediump_ivec2; - /// 2 components vector of low precision signed integer numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of low qualifier signed integer numbers. + /// There is no guarantee on the actual qualifier. typedef vec<2, int, aligned_lowp> aligned_lowp_ivec2; - /// 2 components vector of high precision unsigned integer numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of high qualifier unsigned integer numbers. + /// There is no guarantee on the actual qualifier. typedef vec<2, uint, aligned_highp> aligned_highp_uvec2; - /// 2 components vector of medium precision unsigned integer numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of medium qualifier unsigned integer numbers. + /// There is no guarantee on the actual qualifier. typedef vec<2, uint, aligned_mediump> aligned_mediump_uvec2; - /// 2 components vector of low precision unsigned integer numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of low qualifier unsigned integer numbers. + /// There is no guarantee on the actual qualifier. typedef vec<2, uint, aligned_lowp> aligned_lowp_uvec2; - /// 2 components vector of high precision bool numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of high qualifier bool numbers. + /// There is no guarantee on the actual qualifier. typedef vec<2, bool, aligned_highp> aligned_highp_bvec2; - /// 2 components vector of medium precision bool numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of medium qualifier bool numbers. + /// There is no guarantee on the actual qualifier. typedef vec<2, bool, aligned_mediump> aligned_mediump_bvec2; - /// 2 components vector of low precision bool numbers. - /// There is no guarantee on the actual precision. + /// 2 components vector of low qualifier bool numbers. + /// There is no guarantee on the actual qualifier. typedef vec<2, bool, aligned_lowp> aligned_lowp_bvec2; // -- *vec3 -- - /// 3 components vector of high single-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of high single-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. typedef vec<3, float, aligned_highp> aligned_highp_vec3; - /// 3 components vector of medium single-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of medium single-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. typedef vec<3, float, aligned_mediump> aligned_mediump_vec3; - /// 3 components vector of low single-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of low single-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. typedef vec<3, float, aligned_lowp> aligned_lowp_vec3; - /// 3 components vector of high double-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of high double-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. typedef vec<3, double, aligned_highp> aligned_highp_dvec3; - /// 3 components vector of medium double-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of medium double-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. typedef vec<3, double, aligned_mediump> aligned_mediump_dvec3; - /// 3 components vector of low double-precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of low double-qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. typedef vec<3, double, aligned_lowp> aligned_lowp_dvec3; - /// 3 components vector of high precision signed integer numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of high qualifier signed integer numbers. + /// There is no guarantee on the actual qualifier. typedef vec<3, int, aligned_highp> aligned_highp_ivec3; - /// 3 components vector of medium precision signed integer numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of medium qualifier signed integer numbers. + /// There is no guarantee on the actual qualifier. typedef vec<3, int, aligned_mediump> aligned_mediump_ivec3; - /// 3 components vector of low precision signed integer numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of low qualifier signed integer numbers. + /// There is no guarantee on the actual qualifier. typedef vec<3, int, aligned_lowp> aligned_lowp_ivec3; - /// 3 components vector of high precision unsigned integer numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of high qualifier unsigned integer numbers. + /// There is no guarantee on the actual qualifier. typedef vec<3, uint, aligned_highp> aligned_highp_uvec3; - /// 3 components vector of medium precision unsigned integer numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of medium qualifier unsigned integer numbers. + /// There is no guarantee on the actual qualifier. typedef vec<3, uint, aligned_mediump> aligned_mediump_uvec3; - /// 3 components vector of low precision unsigned integer numbers. - /// There is no guarantee on the actual precision. + /// 3 components vector of low qualifier unsigned integer numbers. + /// There is no guarantee on the actual qualifier. typedef vec<3, uint, aligned_lowp> aligned_lowp_uvec3; - /// 3 components vector of high precision bool numbers. + /// 3 components vector of high qualifier bool numbers. typedef vec<3, bool, aligned_highp> aligned_highp_bvec3; - /// 3 components vector of medium precision bool numbers. + /// 3 components vector of medium qualifier bool numbers. typedef vec<3, bool, aligned_mediump> aligned_mediump_bvec3; - /// 3 components vector of low precision bool numbers. + /// 3 components vector of low qualifier bool numbers. typedef vec<3, bool, aligned_lowp> aligned_lowp_bvec3; // -- *vec4 -- - /// 4 components vector of high single-precision floating-point numbers. + /// 4 components vector of high single-qualifier floating-point numbers. typedef vec<4, float, aligned_highp> aligned_highp_vec4; - /// 4 components vector of medium single-precision floating-point numbers. + /// 4 components vector of medium single-qualifier floating-point numbers. typedef vec<4, float, aligned_mediump> aligned_mediump_vec4; - /// 4 components vector of low single-precision floating-point numbers. + /// 4 components vector of low single-qualifier floating-point numbers. typedef vec<4, float, aligned_lowp> aligned_lowp_vec4; - /// 4 components vector of high double-precision floating-point numbers. + /// 4 components vector of high double-qualifier floating-point numbers. typedef vec<4, double, aligned_highp> aligned_highp_dvec4; - /// 4 components vector of medium double-precision floating-point numbers. + /// 4 components vector of medium double-qualifier floating-point numbers. typedef vec<4, double, aligned_mediump> aligned_mediump_dvec4; - /// 4 components vector of low double-precision floating-point numbers. + /// 4 components vector of low double-qualifier floating-point numbers. typedef vec<4, double, aligned_lowp> aligned_lowp_dvec4; - /// 4 components vector of high precision signed integer numbers. + /// 4 components vector of high qualifier signed integer numbers. typedef vec<4, int, aligned_highp> aligned_highp_ivec4; - /// 4 components vector of medium precision signed integer numbers. + /// 4 components vector of medium qualifier signed integer numbers. typedef vec<4, int, aligned_mediump> aligned_mediump_ivec4; - /// 4 components vector of low precision signed integer numbers. + /// 4 components vector of low qualifier signed integer numbers. typedef vec<4, int, aligned_lowp> aligned_lowp_ivec4; - /// 4 components vector of high precision unsigned integer numbers. + /// 4 components vector of high qualifier unsigned integer numbers. typedef vec<4, uint, aligned_highp> aligned_highp_uvec4; - /// 4 components vector of medium precision unsigned integer numbers. + /// 4 components vector of medium qualifier unsigned integer numbers. typedef vec<4, uint, aligned_mediump> aligned_mediump_uvec4; - /// 4 components vector of low precision unsigned integer numbers. + /// 4 components vector of low qualifier unsigned integer numbers. typedef vec<4, uint, aligned_lowp> aligned_lowp_uvec4; - /// 4 components vector of high precision bool numbers. + /// 4 components vector of high qualifier bool numbers. typedef vec<4, bool, aligned_highp> aligned_highp_bvec4; - /// 4 components vector of medium precision bool numbers. + /// 4 components vector of medium qualifier bool numbers. typedef vec<4, bool, aligned_mediump> aligned_mediump_bvec4; - /// 4 components vector of low precision bool numbers. + /// 4 components vector of low qualifier bool numbers. typedef vec<4, bool, aligned_lowp> aligned_lowp_bvec4; // -- default -- @@ -267,16 +267,16 @@ namespace glm typedef aligned_mediump_dvec3 aligned_dvec3; typedef aligned_mediump_dvec4 aligned_dvec4; #else //defined(GLM_PRECISION_HIGHP_DOUBLE) - /// 1 component vector of double-precision floating-point numbers. + /// 1 component vector of double-qualifier floating-point numbers. typedef aligned_highp_dvec1 aligned_dvec1; - /// 2 components vector of double-precision floating-point numbers. + /// 2 components vector of double-qualifier floating-point numbers. typedef aligned_highp_dvec2 aligned_dvec2; - /// 3 components vector of double-precision floating-point numbers. + /// 3 components vector of double-qualifier floating-point numbers. typedef aligned_highp_dvec3 aligned_dvec3; - /// 4 components vector of double-precision floating-point numbers. + /// 4 components vector of double-qualifier floating-point numbers. typedef aligned_highp_dvec4 aligned_dvec4; #endif//GLM_PRECISION diff --git a/glm/gtc/type_precision.hpp b/glm/gtc/type_precision.hpp index 101f427c..20152c91 100644 --- a/glm/gtc/type_precision.hpp +++ b/glm/gtc/type_precision.hpp @@ -7,9 +7,9 @@ /// @defgroup gtc_type_precision GLM_GTC_type_precision /// @ingroup gtc /// -/// @brief Defines specific C++-based precision types. +/// @brief Defines specific C++-based qualifier types. /// -/// @ref core_precision defines types based on GLSL's precision qualifiers. This +/// @ref core_precision defines types based on GLSL's qualifier qualifiers. This /// extension defines types based on explicitly-sized C++ data types. /// /// need to be included to use these functionalities. @@ -44,123 +44,123 @@ namespace glm /// @addtogroup gtc_type_precision /// @{ - /// Low precision 8 bit signed integer type. + /// Low qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 lowp_int8; - /// Low precision 16 bit signed integer type. + /// Low qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 lowp_int16; - /// Low precision 32 bit signed integer type. + /// Low qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 lowp_int32; - /// Low precision 64 bit signed integer type. + /// Low qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 lowp_int64; - /// Low precision 8 bit signed integer type. + /// Low qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 lowp_int8_t; - /// Low precision 16 bit signed integer type. + /// Low qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 lowp_int16_t; - /// Low precision 32 bit signed integer type. + /// Low qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 lowp_int32_t; - /// Low precision 64 bit signed integer type. + /// Low qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 lowp_int64_t; - /// Low precision 8 bit signed integer type. + /// Low qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 lowp_i8; - /// Low precision 16 bit signed integer type. + /// Low qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 lowp_i16; - /// Low precision 32 bit signed integer type. + /// Low qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 lowp_i32; - /// Low precision 64 bit signed integer type. + /// Low qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 lowp_i64; - /// Medium precision 8 bit signed integer type. + /// Medium qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 mediump_int8; - /// Medium precision 16 bit signed integer type. + /// Medium qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 mediump_int16; - /// Medium precision 32 bit signed integer type. + /// Medium qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 mediump_int32; - /// Medium precision 64 bit signed integer type. + /// Medium qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 mediump_int64; - /// Medium precision 8 bit signed integer type. + /// Medium qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 mediump_int8_t; - /// Medium precision 16 bit signed integer type. + /// Medium qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 mediump_int16_t; - /// Medium precision 32 bit signed integer type. + /// Medium qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 mediump_int32_t; - /// Medium precision 64 bit signed integer type. + /// Medium qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 mediump_int64_t; - /// Medium precision 8 bit signed integer type. + /// Medium qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 mediump_i8; - /// Medium precision 16 bit signed integer type. + /// Medium qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 mediump_i16; - /// Medium precision 32 bit signed integer type. + /// Medium qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 mediump_i32; - /// Medium precision 64 bit signed integer type. + /// Medium qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 mediump_i64; - /// High precision 8 bit signed integer type. + /// High qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 highp_int8; - /// High precision 16 bit signed integer type. + /// High qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 highp_int16; - /// High precision 32 bit signed integer type. + /// High qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 highp_int32; - /// High precision 64 bit signed integer type. + /// High qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 highp_int64; - /// High precision 8 bit signed integer type. + /// High qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 highp_int8_t; - /// High precision 16 bit signed integer type. + /// High qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 highp_int16_t; @@ -168,23 +168,23 @@ namespace glm /// @see gtc_type_precision typedef detail::int32 highp_int32_t; - /// High precision 64 bit signed integer type. + /// High qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 highp_int64_t; - /// High precision 8 bit signed integer type. + /// High qualifier 8 bit signed integer type. /// @see gtc_type_precision typedef detail::int8 highp_i8; - /// High precision 16 bit signed integer type. + /// High qualifier 16 bit signed integer type. /// @see gtc_type_precision typedef detail::int16 highp_i16; - /// High precision 32 bit signed integer type. + /// High qualifier 32 bit signed integer type. /// @see gtc_type_precision typedef detail::int32 highp_i32; - /// High precision 64 bit signed integer type. + /// High qualifier 64 bit signed integer type. /// @see gtc_type_precision typedef detail::int64 highp_i64; @@ -316,163 +316,163 @@ namespace glm ///////////////////////////// // Unsigned int vector types - /// Low precision 8 bit unsigned integer type. + /// Low qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 lowp_uint8; - /// Low precision 16 bit unsigned integer type. + /// Low qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 lowp_uint16; - /// Low precision 32 bit unsigned integer type. + /// Low qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 lowp_uint32; - /// Low precision 64 bit unsigned integer type. + /// Low qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 lowp_uint64; - /// Low precision 8 bit unsigned integer type. + /// Low qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 lowp_uint8_t; - /// Low precision 16 bit unsigned integer type. + /// Low qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 lowp_uint16_t; - /// Low precision 32 bit unsigned integer type. + /// Low qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 lowp_uint32_t; - /// Low precision 64 bit unsigned integer type. + /// Low qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 lowp_uint64_t; - /// Low precision 8 bit unsigned integer type. + /// Low qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 lowp_u8; - /// Low precision 16 bit unsigned integer type. + /// Low qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 lowp_u16; - /// Low precision 32 bit unsigned integer type. + /// Low qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 lowp_u32; - /// Low precision 64 bit unsigned integer type. + /// Low qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 lowp_u64; - /// Medium precision 8 bit unsigned integer type. + /// Medium qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 mediump_uint8; - /// Medium precision 16 bit unsigned integer type. + /// Medium qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 mediump_uint16; - /// Medium precision 32 bit unsigned integer type. + /// Medium qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 mediump_uint32; - /// Medium precision 64 bit unsigned integer type. + /// Medium qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 mediump_uint64; - /// Medium precision 8 bit unsigned integer type. + /// Medium qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 mediump_uint8_t; - /// Medium precision 16 bit unsigned integer type. + /// Medium qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 mediump_uint16_t; - /// Medium precision 32 bit unsigned integer type. + /// Medium qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 mediump_uint32_t; - /// Medium precision 64 bit unsigned integer type. + /// Medium qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 mediump_uint64_t; - /// Medium precision 8 bit unsigned integer type. + /// Medium qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 mediump_u8; - /// Medium precision 16 bit unsigned integer type. + /// Medium qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 mediump_u16; - /// Medium precision 32 bit unsigned integer type. + /// Medium qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 mediump_u32; - /// Medium precision 64 bit unsigned integer type. + /// Medium qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 mediump_u64; - /// High precision 8 bit unsigned integer type. + /// High qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 highp_uint8; - /// High precision 16 bit unsigned integer type. + /// High qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 highp_uint16; - /// High precision 32 bit unsigned integer type. + /// High qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 highp_uint32; - /// High precision 64 bit unsigned integer type. + /// High qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 highp_uint64; - /// High precision 8 bit unsigned integer type. + /// High qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 highp_uint8_t; - /// High precision 16 bit unsigned integer type. + /// High qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 highp_uint16_t; - /// High precision 32 bit unsigned integer type. + /// High qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 highp_uint32_t; - /// High precision 64 bit unsigned integer type. + /// High qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 highp_uint64_t; - /// High precision 8 bit unsigned integer type. + /// High qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 highp_u8; - /// High precision 16 bit unsigned integer type. + /// High qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 highp_u16; - /// High precision 32 bit unsigned integer type. + /// High qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 highp_u32; - /// High precision 64 bit unsigned integer type. + /// High qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 highp_u64; - /// Default precision 8 bit unsigned integer type. + /// Default qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 uint8; - /// Default precision 16 bit unsigned integer type. + /// Default qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 uint16; - /// Default precision 32 bit unsigned integer type. + /// Default qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 uint32; - /// Default precision 64 bit unsigned integer type. + /// Default qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 uint64; @@ -482,105 +482,105 @@ namespace glm using std::uint32_t; using std::uint64_t; #else - /// Default precision 8 bit unsigned integer type. + /// Default qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 uint8_t; - /// Default precision 16 bit unsigned integer type. + /// Default qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 uint16_t; - /// Default precision 32 bit unsigned integer type. + /// Default qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 uint32_t; - /// Default precision 64 bit unsigned integer type. + /// Default qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 uint64_t; #endif - /// Default precision 8 bit unsigned integer type. + /// Default qualifier 8 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint8 u8; - /// Default precision 16 bit unsigned integer type. + /// Default qualifier 16 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint16 u16; - /// Default precision 32 bit unsigned integer type. + /// Default qualifier 32 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint32 u32; - /// Default precision 64 bit unsigned integer type. + /// Default qualifier 64 bit unsigned integer type. /// @see gtc_type_precision typedef detail::uint64 u64; - /// Default precision 8 bit unsigned integer scalar type. + /// Default qualifier 8 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u8, defaultp> u8vec1; - /// Default precision 8 bit unsigned integer vector of 2 components type. + /// Default qualifier 8 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u8, defaultp> u8vec2; - /// Default precision 8 bit unsigned integer vector of 3 components type. + /// Default qualifier 8 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u8, defaultp> u8vec3; - /// Default precision 8 bit unsigned integer vector of 4 components type. + /// Default qualifier 8 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u8, defaultp> u8vec4; - /// Default precision 16 bit unsigned integer scalar type. + /// Default qualifier 16 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u16, defaultp> u16vec1; - /// Default precision 16 bit unsigned integer vector of 2 components type. + /// Default qualifier 16 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u16, defaultp> u16vec2; - /// Default precision 16 bit unsigned integer vector of 3 components type. + /// Default qualifier 16 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u16, defaultp> u16vec3; - /// Default precision 16 bit unsigned integer vector of 4 components type. + /// Default qualifier 16 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u16, defaultp> u16vec4; - /// Default precision 32 bit unsigned integer scalar type. + /// Default qualifier 32 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u32, defaultp> u32vec1; - /// Default precision 32 bit unsigned integer vector of 2 components type. + /// Default qualifier 32 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u32, defaultp> u32vec2; - /// Default precision 32 bit unsigned integer vector of 3 components type. + /// Default qualifier 32 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u32, defaultp> u32vec3; - /// Default precision 32 bit unsigned integer vector of 4 components type. + /// Default qualifier 32 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u32, defaultp> u32vec4; - /// Default precision 64 bit unsigned integer scalar type. + /// Default qualifier 64 bit unsigned integer scalar type. /// @see gtc_type_precision typedef vec<1, u64, defaultp> u64vec1; - /// Default precision 64 bit unsigned integer vector of 2 components type. + /// Default qualifier 64 bit unsigned integer vector of 2 components type. /// @see gtc_type_precision typedef vec<2, u64, defaultp> u64vec2; - /// Default precision 64 bit unsigned integer vector of 3 components type. + /// Default qualifier 64 bit unsigned integer vector of 3 components type. /// @see gtc_type_precision typedef vec<3, u64, defaultp> u64vec3; - /// Default precision 64 bit unsigned integer vector of 4 components type. + /// Default qualifier 64 bit unsigned integer vector of 4 components type. /// @see gtc_type_precision typedef vec<4, u64, defaultp> u64vec4; @@ -588,80 +588,80 @@ namespace glm ////////////////////// // Float vector types - /// 32 bit single-precision floating-point scalar. + /// 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 float32; - /// 64 bit double-precision floating-point scalar. + /// 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 float64; - /// 32 bit single-precision floating-point scalar. + /// 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float32 float32_t; - /// 64 bit double-precision floating-point scalar. + /// 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef detail::float64 float64_t; - /// 32 bit single-precision floating-point scalar. + /// 32 bit single-qualifier floating-point scalar. /// @see gtc_type_precision typedef float32 f32; - /// 64 bit double-precision floating-point scalar. + /// 64 bit double-qualifier floating-point scalar. /// @see gtc_type_precision typedef float64 f64; - /// Single-precision floating-point vector of 1 component. + /// Single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, float, defaultp> fvec1; - /// Single-precision floating-point vector of 2 components. + /// Single-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, float, defaultp> fvec2; - /// Single-precision floating-point vector of 3 components. + /// Single-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, float, defaultp> fvec3; - /// Single-precision floating-point vector of 4 components. + /// Single-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, float, defaultp> fvec4; - /// Single-precision floating-point vector of 1 component. + /// Single-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f32, defaultp> f32vec1; - /// Single-precision floating-point vector of 2 components. + /// Single-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, f32, defaultp> f32vec2; - /// Single-precision floating-point vector of 3 components. + /// Single-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, f32, defaultp> f32vec3; - /// Single-precision floating-point vector of 4 components. + /// Single-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, f32, defaultp> f32vec4; - /// Double-precision floating-point vector of 1 component. + /// Double-qualifier floating-point vector of 1 component. /// @see gtc_type_precision typedef vec<1, f64, defaultp> f64vec1; - /// Double-precision floating-point vector of 2 components. + /// Double-qualifier floating-point vector of 2 components. /// @see gtc_type_precision typedef vec<2, f64, defaultp> f64vec2; - /// Double-precision floating-point vector of 3 components. + /// Double-qualifier floating-point vector of 3 components. /// @see gtc_type_precision typedef vec<3, f64, defaultp> f64vec3; - /// Double-precision floating-point vector of 4 components. + /// Double-qualifier floating-point vector of 4 components. /// @see gtc_type_precision typedef vec<4, f64, defaultp> f64vec4; @@ -669,176 +669,176 @@ namespace glm ////////////////////// // Float matrix types - /// Single-precision floating-point 1x1 matrix. + /// Single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef detail::tmat1x1 fmat1; - /// Single-precision floating-point 2x2 matrix. + /// Single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, defaultp> fmat2; - /// Single-precision floating-point 3x3 matrix. + /// Single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, defaultp> fmat3; - /// Single-precision floating-point 4x4 matrix. + /// Single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, defaultp> fmat4; - /// Single-precision floating-point 1x1 matrix. + /// Single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f32 fmat1x1; - /// Single-precision floating-point 2x2 matrix. + /// Single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, defaultp> fmat2x2; - /// Single-precision floating-point 2x3 matrix. + /// Single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, defaultp> fmat2x3; - /// Single-precision floating-point 2x4 matrix. + /// Single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, defaultp> fmat2x4; - /// Single-precision floating-point 3x2 matrix. + /// Single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, defaultp> fmat3x2; - /// Single-precision floating-point 3x3 matrix. + /// Single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, defaultp> fmat3x3; - /// Single-precision floating-point 3x4 matrix. + /// Single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, defaultp> fmat3x4; - /// Single-precision floating-point 4x2 matrix. + /// Single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, defaultp> fmat4x2; - /// Single-precision floating-point 4x3 matrix. + /// Single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, defaultp> fmat4x3; - /// Single-precision floating-point 4x4 matrix. + /// Single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, defaultp> fmat4x4; - /// Single-precision floating-point 1x1 matrix. + /// Single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef detail::tmat1x1 f32mat1; - /// Single-precision floating-point 2x2 matrix. + /// Single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, defaultp> f32mat2; - /// Single-precision floating-point 3x3 matrix. + /// Single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, defaultp> f32mat3; - /// Single-precision floating-point 4x4 matrix. + /// Single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, defaultp> f32mat4; - /// Single-precision floating-point 1x1 matrix. + /// Single-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f32 f32mat1x1; - /// Single-precision floating-point 2x2 matrix. + /// Single-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f32, defaultp> f32mat2x2; - /// Single-precision floating-point 2x3 matrix. + /// Single-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f32, defaultp> f32mat2x3; - /// Single-precision floating-point 2x4 matrix. + /// Single-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f32, defaultp> f32mat2x4; - /// Single-precision floating-point 3x2 matrix. + /// Single-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f32, defaultp> f32mat3x2; - /// Single-precision floating-point 3x3 matrix. + /// Single-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f32, defaultp> f32mat3x3; - /// Single-precision floating-point 3x4 matrix. + /// Single-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f32, defaultp> f32mat3x4; - /// Single-precision floating-point 4x2 matrix. + /// Single-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f32, defaultp> f32mat4x2; - /// Single-precision floating-point 4x3 matrix. + /// Single-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f32, defaultp> f32mat4x3; - /// Single-precision floating-point 4x4 matrix. + /// Single-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f32, defaultp> f32mat4x4; - /// Double-precision floating-point 1x1 matrix. + /// Double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef detail::tmat1x1 f64mat1; - /// Double-precision floating-point 2x2 matrix. + /// Double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f64, defaultp> f64mat2; - /// Double-precision floating-point 3x3 matrix. + /// Double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f64, defaultp> f64mat3; - /// Double-precision floating-point 4x4 matrix. + /// Double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f64, defaultp> f64mat4; - /// Double-precision floating-point 1x1 matrix. + /// Double-qualifier floating-point 1x1 matrix. /// @see gtc_type_precision //typedef f64 f64mat1x1; - /// Double-precision floating-point 2x2 matrix. + /// Double-qualifier floating-point 2x2 matrix. /// @see gtc_type_precision typedef mat<2, 2, f64, defaultp> f64mat2x2; - /// Double-precision floating-point 2x3 matrix. + /// Double-qualifier floating-point 2x3 matrix. /// @see gtc_type_precision typedef mat<2, 3, f64, defaultp> f64mat2x3; - /// Double-precision floating-point 2x4 matrix. + /// Double-qualifier floating-point 2x4 matrix. /// @see gtc_type_precision typedef mat<2, 4, f64, defaultp> f64mat2x4; - /// Double-precision floating-point 3x2 matrix. + /// Double-qualifier floating-point 3x2 matrix. /// @see gtc_type_precision typedef mat<3, 2, f64, defaultp> f64mat3x2; - /// Double-precision floating-point 3x3 matrix. + /// Double-qualifier floating-point 3x3 matrix. /// @see gtc_type_precision typedef mat<3, 3, f64, defaultp> f64mat3x3; - /// Double-precision floating-point 3x4 matrix. + /// Double-qualifier floating-point 3x4 matrix. /// @see gtc_type_precision typedef mat<3, 4, f64, defaultp> f64mat3x4; - /// Double-precision floating-point 4x2 matrix. + /// Double-qualifier floating-point 4x2 matrix. /// @see gtc_type_precision typedef mat<4, 2, f64, defaultp> f64mat4x2; - /// Double-precision floating-point 4x3 matrix. + /// Double-qualifier floating-point 4x3 matrix. /// @see gtc_type_precision typedef mat<4, 3, f64, defaultp> f64mat4x3; - /// Double-precision floating-point 4x4 matrix. + /// Double-qualifier floating-point 4x4 matrix. /// @see gtc_type_precision typedef mat<4, 4, f64, defaultp> f64mat4x4; @@ -846,11 +846,11 @@ namespace glm ////////////////////////// // Quaternion types - /// Single-precision floating-point quaternion. + /// Single-qualifier floating-point quaternion. /// @see gtc_type_precision typedef tquat f32quat; - /// Double-precision floating-point quaternion. + /// Double-qualifier floating-point quaternion. /// @see gtc_type_precision typedef tquat f64quat; diff --git a/glm/gtc/type_ptr.inl b/glm/gtc/type_ptr.inl index 1b2392cf..66468bfa 100644 --- a/glm/gtc/type_ptr.inl +++ b/glm/gtc/type_ptr.inl @@ -10,7 +10,7 @@ namespace glm /// Return the constant address to the data of the vector input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T const* value_ptr(vec<2, T, P> const& v) { return &(v.x); @@ -18,7 +18,7 @@ namespace glm //! Return the address to the data of the vector input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T* value_ptr(vec<2, T, P>& v) { return &(v.x); @@ -26,7 +26,7 @@ namespace glm /// Return the constant address to the data of the vector input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T const * value_ptr(vec<3, T, P> const& v) { return &(v.x); @@ -34,7 +34,7 @@ namespace glm //! Return the address to the data of the vector input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T* value_ptr(vec<3, T, P>& v) { return &(v.x); @@ -42,7 +42,7 @@ namespace glm /// Return the constant address to the data of the vector input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T const* value_ptr(vec<4, T, P> const& v) { return &(v.x); @@ -50,7 +50,7 @@ namespace glm //! Return the address to the data of the vector input. //! From GLM_GTC_type_ptr extension. - template + template GLM_FUNC_QUALIFIER T* value_ptr(vec<4, T, P>& v) { return &(v.x); @@ -58,7 +58,7 @@ namespace glm /// Return the constant address to the data of the matrix input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T const* value_ptr(mat<2, 2, T, P> const& m) { return &(m[0].x); @@ -66,7 +66,7 @@ namespace glm //! Return the address to the data of the matrix input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T* value_ptr(mat<2, 2, T, P>& m) { return &(m[0].x); @@ -74,7 +74,7 @@ namespace glm /// Return the constant address to the data of the matrix input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T const* value_ptr(mat<3, 3, T, P> const& m) { return &(m[0].x); @@ -82,7 +82,7 @@ namespace glm //! Return the address to the data of the matrix input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T* value_ptr(mat<3, 3, T, P>& m) { return &(m[0].x); @@ -90,7 +90,7 @@ namespace glm /// Return the constant address to the data of the matrix input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T const* value_ptr(mat<4, 4, T, P> const& m) { return &(m[0].x); @@ -98,7 +98,7 @@ namespace glm //! Return the address to the data of the matrix input. //! From GLM_GTC_type_ptr extension. - template + template GLM_FUNC_QUALIFIER T* value_ptr(mat<4, 4, T, P>& m) { return &(m[0].x); @@ -106,7 +106,7 @@ namespace glm /// Return the constant address to the data of the matrix input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T const* value_ptr(mat<2, 3, T, P> const& m) { return &(m[0].x); @@ -114,7 +114,7 @@ namespace glm //! Return the address to the data of the matrix input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T* value_ptr(mat<2, 3, T, P>& m) { return &(m[0].x); @@ -122,7 +122,7 @@ namespace glm /// Return the constant address to the data of the matrix input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T const* value_ptr(mat<3, 2, T, P> const& m) { return &(m[0].x); @@ -130,7 +130,7 @@ namespace glm //! Return the address to the data of the matrix input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T* value_ptr(mat<3, 2, T, P>& m) { return &(m[0].x); @@ -138,7 +138,7 @@ namespace glm /// Return the constant address to the data of the matrix input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T const* value_ptr(mat<2, 4, T, P> const& m) { return &(m[0].x); @@ -146,7 +146,7 @@ namespace glm //! Return the address to the data of the matrix input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T* value_ptr(mat<2, 4, T, P>& m) { return &(m[0].x); @@ -154,7 +154,7 @@ namespace glm /// Return the constant address to the data of the matrix input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T const* value_ptr(mat<4, 2, T, P> const& m) { return &(m[0].x); @@ -162,7 +162,7 @@ namespace glm //! Return the address to the data of the matrix input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T* value_ptr(mat<4, 2, T, P>& m) { return &(m[0].x); @@ -170,7 +170,7 @@ namespace glm /// Return the constant address to the data of the matrix input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T const* value_ptr(mat<3, 4, T, P> const& m) { return &(m[0].x); @@ -178,7 +178,7 @@ namespace glm //! Return the address to the data of the matrix input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T* value_ptr(mat<3, 4, T, P>& m) { return &(m[0].x); @@ -186,7 +186,7 @@ namespace glm /// Return the constant address to the data of the matrix input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T const* value_ptr(mat<4, 3, T, P> const& m) { return &(m[0].x); @@ -194,7 +194,7 @@ namespace glm /// Return the address to the data of the matrix input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T * value_ptr(mat<4, 3, T, P>& m) { return &(m[0].x); @@ -202,7 +202,7 @@ namespace glm /// Return the constant address to the data of the input parameter. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T const * value_ptr(tquat const& q) { return &(q[0]); @@ -210,7 +210,7 @@ namespace glm /// Return the address to the data of the quaternion input. /// @see gtc_type_ptr - template + template GLM_FUNC_QUALIFIER T* value_ptr(tquat& q) { return &(q[0]); diff --git a/glm/gtc/ulp.hpp b/glm/gtc/ulp.hpp index 859a2aea..2f41bb65 100644 --- a/glm/gtc/ulp.hpp +++ b/glm/gtc/ulp.hpp @@ -15,7 +15,7 @@ // Dependencies #include "../detail/setup.hpp" -#include "../detail/precision.hpp" +#include "../detail/qualifier.hpp" #include "../detail/type_int.hpp" #include "../detail/compute_vector_relational.hpp" @@ -55,8 +55,8 @@ namespace glm /// Return the distance in the number of ULP between 2 vectors. /// @see gtc_ulp - template class vecType> - GLM_FUNC_DECL vecType<2, uint> float_distance(vecType<2, T> const & x, vecType<2, T> const & y); + template + GLM_FUNC_DECL vec<2, uint, Q> float_distance(vec<2, T, Q> const & x, vec<2, T, Q> const & y); /// @} }// namespace glm diff --git a/glm/gtc/ulp.inl b/glm/gtc/ulp.inl index d4e718d6..5019287a 100644 --- a/glm/gtc/ulp.inl +++ b/glm/gtc/ulp.inl @@ -217,10 +217,10 @@ namespace glm # endif } - template class vecType> - GLM_FUNC_QUALIFIER vecType next_float(vecType const & x) + template + GLM_FUNC_QUALIFIER vec next_float(vec const & x) { - vecType Result; + vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = next_float(x[i]); return Result; @@ -252,10 +252,10 @@ namespace glm # endif } - template class vecType> - GLM_FUNC_QUALIFIER vecType prev_float(vecType const & x) + template + GLM_FUNC_QUALIFIER vec prev_float(vec const & x) { - vecType Result; + vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = prev_float(x[i]); return Result; @@ -270,10 +270,10 @@ namespace glm return temp; } - template class vecType> - GLM_FUNC_QUALIFIER vecType next_float(vecType const & x, vecType const & ulps) + template + GLM_FUNC_QUALIFIER vec next_float(vec const & x, vec const & ulps) { - vecType Result; + vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = next_float(x[i], ulps[i]); return Result; @@ -288,10 +288,10 @@ namespace glm return temp; } - template class vecType> - GLM_FUNC_QUALIFIER vecType prev_float(vecType const & x, vecType const & ulps) + template + GLM_FUNC_QUALIFIER vec prev_float(vec const & x, vec const & ulps) { - vecType Result; + vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = prev_float(x[i], ulps[i]); return Result; @@ -328,10 +328,10 @@ namespace glm return ulp; } - template class vecType> - GLM_FUNC_QUALIFIER vecType float_distance(vecType const & x, vecType const & y) + template + GLM_FUNC_QUALIFIER vec float_distance(vec const & x, vec const & y) { - vecType Result; + vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = float_distance(x[i], y[i]); return Result; diff --git a/glm/gtc/vec1.hpp b/glm/gtc/vec1.hpp index f84ff97c..21a882a7 100644 --- a/glm/gtc/vec1.hpp +++ b/glm/gtc/vec1.hpp @@ -21,78 +21,78 @@ namespace glm { - /// 1 component vector of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 1 component vector of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// @see gtc_vec1 extension. typedef highp_vec1_t highp_vec1; - /// 1 component vector of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 1 component vector of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// @see gtc_vec1 extension. typedef mediump_vec1_t mediump_vec1; - /// 1 component vector of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 1 component vector of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// @see gtc_vec1 extension. typedef lowp_vec1_t lowp_vec1; - /// 1 component vector of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 1 component vector of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// @see gtc_vec1 extension. typedef highp_dvec1_t highp_dvec1; - /// 1 component vector of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 1 component vector of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// @see gtc_vec1 extension. typedef mediump_dvec1_t mediump_dvec1; - /// 1 component vector of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 1 component vector of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// @see gtc_vec1 extension. typedef lowp_dvec1_t lowp_dvec1; - /// 1 component vector of high precision signed integer numbers. - /// There is no guarantee on the actual precision. + /// 1 component vector of high qualifier signed integer numbers. + /// There is no guarantee on the actual qualifier. /// @see gtc_vec1 extension. typedef highp_ivec1_t highp_ivec1; - /// 1 component vector of medium precision signed integer numbers. - /// There is no guarantee on the actual precision. + /// 1 component vector of medium qualifier signed integer numbers. + /// There is no guarantee on the actual qualifier. /// @see gtc_vec1 extension. typedef mediump_ivec1_t mediump_ivec1; - /// 1 component vector of low precision signed integer numbers. - /// There is no guarantee on the actual precision. + /// 1 component vector of low qualifier signed integer numbers. + /// There is no guarantee on the actual qualifier. /// @see gtc_vec1 extension. typedef lowp_ivec1_t lowp_ivec1; - /// 1 component vector of high precision unsigned integer numbers. - /// There is no guarantee on the actual precision. + /// 1 component vector of high qualifier unsigned integer numbers. + /// There is no guarantee on the actual qualifier. /// @see gtc_vec1 extension. typedef highp_uvec1_t highp_uvec1; - /// 1 component vector of medium precision unsigned integer numbers. - /// There is no guarantee on the actual precision. + /// 1 component vector of medium qualifier unsigned integer numbers. + /// There is no guarantee on the actual qualifier. /// @see gtc_vec1 extension. typedef mediump_uvec1_t mediump_uvec1; - /// 1 component vector of low precision unsigned integer numbers. - /// There is no guarantee on the actual precision. + /// 1 component vector of low qualifier unsigned integer numbers. + /// There is no guarantee on the actual qualifier. /// @see gtc_vec1 extension. typedef lowp_uvec1_t lowp_uvec1; - /// 1 component vector of high precision boolean. - /// There is no guarantee on the actual precision. + /// 1 component vector of high qualifier boolean. + /// There is no guarantee on the actual qualifier. /// @see gtc_vec1 extension. typedef highp_bvec1_t highp_bvec1; - /// 1 component vector of medium precision boolean. - /// There is no guarantee on the actual precision. + /// 1 component vector of medium qualifier boolean. + /// There is no guarantee on the actual qualifier. /// @see gtc_vec1 extension. typedef mediump_bvec1_t mediump_bvec1; - /// 1 component vector of low precision boolean. - /// There is no guarantee on the actual precision. + /// 1 component vector of low qualifier boolean. + /// There is no guarantee on the actual qualifier. /// @see gtc_vec1 extension. typedef lowp_bvec1_t lowp_bvec1; diff --git a/glm/gtx/associated_min_max.hpp b/glm/gtx/associated_min_max.hpp index ec66bb7f..ce07b1db 100644 --- a/glm/gtx/associated_min_max.hpp +++ b/glm/gtx/associated_min_max.hpp @@ -30,29 +30,29 @@ namespace glm /// Minimum comparison between 2 variables and returns 2 associated variable values /// @see gtx_associated_min_max - template + 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> + template GLM_FUNC_DECL vec<2, U, P> associatedMin( - vecType const& x, vecType const & a, - vecType const& y, vecType const & b); + vec const& x, vec const & a, + vec const& y, vec 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); + template + GLM_FUNC_DECL vec associatedMin( + T x, const vec& a, + T y, const vec& 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); + template + GLM_FUNC_DECL vec associatedMin( + vec const& x, U a, + vec const& y, U b); /// Minimum comparison between 3 variables and returns 3 associated variable values /// @see gtx_associated_min_max @@ -64,11 +64,11 @@ namespace glm /// 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); + template + GLM_FUNC_DECL vec associatedMin( + vec const& x, vec const & a, + vec const& y, vec const & b, + vec const& z, vec const & c); /// Minimum comparison between 4 variables and returns 4 associated variable values /// @see gtx_associated_min_max @@ -81,30 +81,30 @@ namespace glm /// 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); + template + GLM_FUNC_DECL vec associatedMin( + vec const& x, vec const & a, + vec const& y, vec const & b, + vec const& z, vec const & c, + vec const& w, vec 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); + template + GLM_FUNC_DECL vec associatedMin( + T x, vec const & a, + T y, vec const & b, + T z, vec const & c, + T w, vec 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); + template + GLM_FUNC_DECL vec associatedMin( + vec const& x, U a, + vec const& y, U b, + vec const& z, U c, + vec const& w, U d); /// Maximum comparison between 2 variables and returns 2 associated variable values /// @see gtx_associated_min_max @@ -113,24 +113,24 @@ namespace glm /// Maximum comparison between 2 variables and returns 2 associated variable values /// @see gtx_associated_min_max - template class vecType> + template GLM_FUNC_DECL vec<2, U, P> associatedMax( - vecType const& x, vecType const & a, - vecType const& y, vecType const & b); + vec const& x, vec const & a, + vec const& y, vec 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); + template + GLM_FUNC_DECL vec associatedMax( + T x, vec const & a, + T y, vec 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); + template + GLM_FUNC_DECL vec associatedMax( + vec const& x, U a, + vec const& y, U b); /// Maximum comparison between 3 variables and returns 3 associated variable values /// @see gtx_associated_min_max @@ -142,27 +142,27 @@ namespace glm /// 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); + template + GLM_FUNC_DECL vec associatedMax( + vec const& x, vec const & a, + vec const& y, vec const & b, + vec const& z, vec 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); + template + GLM_FUNC_DECL vec associatedMax( + T x, vec const & a, + T y, vec const & b, + T z, vec 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); + template + GLM_FUNC_DECL vec associatedMax( + vec const& x, U a, + vec const& y, U b, + vec const& z, U c); /// Maximum comparison between 4 variables and returns 4 associated variable values /// @see gtx_associated_min_max @@ -175,30 +175,30 @@ namespace glm /// 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); + template + GLM_FUNC_DECL vec associatedMax( + vec const& x, vec const & a, + vec const& y, vec const & b, + vec const& z, vec const & c, + vec const& w, vec 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); + template + GLM_FUNC_DECL vec associatedMax( + T x, vec const & a, + T y, vec const & b, + T z, vec const & c, + T w, vec 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); + template + GLM_FUNC_DECL vec associatedMax( + vec const& x, U a, + vec const& y, U b, + vec const& z, U c, + vec const& w, U d); /// @} } //namespace glm diff --git a/glm/gtx/associated_min_max.inl b/glm/gtx/associated_min_max.inl index 94bb3da2..a5a32f4a 100644 --- a/glm/gtx/associated_min_max.inl +++ b/glm/gtx/associated_min_max.inl @@ -4,46 +4,46 @@ namespace glm{ // Min comparison between 2 variables -template +template GLM_FUNC_QUALIFIER U associatedMin(T x, U a, T y, U b) { return x < y ? a : b; } -template class vecType> +template GLM_FUNC_QUALIFIER vec<2, U, P> associatedMin ( - vecType const& x, vecType const & a, - vecType const& y, vecType const & b + vec const& x, vec const & a, + vec const& y, vec const & b ) { - vecType Result; + vec Result; 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 +template +GLM_FUNC_QUALIFIER vec associatedMin ( - T x, const vecType& a, - T y, const vecType& b + T x, const vec& a, + T y, const vec& b ) { - vecType Result; + vec Result; 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 +template +GLM_FUNC_QUALIFIER vec associatedMin ( - vecType const& x, U a, - vecType const& y, U b + vec const& x, U a, + vec const& y, U b ) { - vecType Result; + vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = x[i] < y[i] ? a : b; return Result; @@ -62,15 +62,15 @@ GLM_FUNC_QUALIFIER U associatedMin return Result; } -template class vecType> -GLM_FUNC_QUALIFIER vecType associatedMin +template +GLM_FUNC_QUALIFIER vec associatedMin ( - vecType const& x, vecType const & a, - vecType const& y, vecType const & b, - vecType const& z, vecType const & c + vec const& x, vec const & a, + vec const& y, vec const & b, + vec const& z, vec const & c ) { - vecType Result; + vec Result; 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; @@ -95,16 +95,16 @@ GLM_FUNC_QUALIFIER U associatedMin } // Min comparison between 4 variables -template class vecType> -GLM_FUNC_QUALIFIER vecType associatedMin +template +GLM_FUNC_QUALIFIER vec 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 + vec const& x, vec const & a, + vec const& y, vec const & b, + vec const& z, vec const & c, + vec const& w, vec const & d ) { - vecType Result; + vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) { T Test1 = min(x[i], y[i]); @@ -117,19 +117,19 @@ GLM_FUNC_QUALIFIER vecType associatedMin } // Min comparison between 4 variables -template class vecType> -GLM_FUNC_QUALIFIER vecType associatedMin +template +GLM_FUNC_QUALIFIER vec associatedMin ( - T x, vecType const & a, - T y, vecType const & b, - T z, vecType const & c, - T w, vecType const & d + T x, vec const & a, + T y, vec const & b, + T z, vec const & c, + T w, vec const & d ) { T Test1 = min(x, y); T Test2 = min(z, w); - vecType Result; + vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) { U Result1 = x < y ? a[i] : b[i]; @@ -140,16 +140,16 @@ GLM_FUNC_QUALIFIER vecType associatedMin } // Min comparison between 4 variables -template class vecType> -GLM_FUNC_QUALIFIER vecType associatedMin +template +GLM_FUNC_QUALIFIER vec associatedMin ( - vecType const& x, U a, - vecType const& y, U b, - vecType const& z, U c, - vecType const& w, U d + vec const& x, U a, + vec const& y, U b, + vec const& z, U c, + vec const& w, U d ) { - vecType Result; + vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) { T Test1 = min(x[i], y[i]); @@ -169,42 +169,42 @@ GLM_FUNC_QUALIFIER U associatedMax(T x, U a, T y, U b) } // Max comparison between 2 variables -template class vecType> +template GLM_FUNC_QUALIFIER vec<2, U, P> associatedMax ( - vecType const& x, vecType const & a, - vecType const& y, vecType const & b + vec const& x, vec const & a, + vec const& y, vec const & b ) { - vecType Result; + vec Result; 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 +template +GLM_FUNC_QUALIFIER vec associatedMax ( - T x, vecType const & a, - T y, vecType const & b + T x, vec const & a, + T y, vec const & b ) { - vecType Result; + vec Result; 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 +template +GLM_FUNC_QUALIFIER vec associatedMax ( - vecType const& x, U a, - vecType const& y, U b + vec const& x, U a, + vec const& y, U b ) { - vecType Result; + vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) Result[i] = x[i] > y[i] ? a : b; return Result; @@ -224,45 +224,45 @@ GLM_FUNC_QUALIFIER U associatedMax } // Max comparison between 3 variables -template class vecType> -GLM_FUNC_QUALIFIER vecType associatedMax +template +GLM_FUNC_QUALIFIER vec associatedMax ( - vecType const& x, vecType const & a, - vecType const& y, vecType const & b, - vecType const& z, vecType const & c + vec const& x, vec const & a, + vec const& y, vec const & b, + vec const& z, vec const & c ) { - vecType Result; + vec Result; 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 +template +GLM_FUNC_QUALIFIER vec associatedMax ( - T x, vecType const & a, - T y, vecType const & b, - T z, vecType const & c + T x, vec const & a, + T y, vec const & b, + T z, vec const & c ) { - vecType Result; + vec Result; 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 +template +GLM_FUNC_QUALIFIER vec associatedMax ( - vecType const& x, U a, - vecType const& y, U b, - vecType const& z, U c + vec const& x, U a, + vec const& y, U b, + vec const& z, U c ) { - vecType Result; + vec Result; 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; @@ -287,16 +287,16 @@ GLM_FUNC_QUALIFIER U associatedMax } // Max comparison between 4 variables -template class vecType> -GLM_FUNC_QUALIFIER vecType associatedMax +template +GLM_FUNC_QUALIFIER vec 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 + vec const& x, vec const & a, + vec const& y, vec const & b, + vec const& z, vec const & c, + vec const& w, vec const & d ) { - vecType Result; + vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) { T Test1 = max(x[i], y[i]); @@ -309,19 +309,19 @@ GLM_FUNC_QUALIFIER vecType associatedMax } // Max comparison between 4 variables -template class vecType> -GLM_FUNC_QUALIFIER vecType associatedMax +template +GLM_FUNC_QUALIFIER vec associatedMax ( - T x, vecType const & a, - T y, vecType const & b, - T z, vecType const & c, - T w, vecType const & d + T x, vec const & a, + T y, vec const & b, + T z, vec const & c, + T w, vec const & d ) { T Test1 = max(x, y); T Test2 = max(z, w); - vecType Result; + vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) { U Result1 = x > y ? a[i] : b[i]; @@ -332,16 +332,16 @@ GLM_FUNC_QUALIFIER vecType associatedMax } // Max comparison between 4 variables -template class vecType> -GLM_FUNC_QUALIFIER vecType associatedMax +template +GLM_FUNC_QUALIFIER vec associatedMax ( - vecType const& x, U a, - vecType const& y, U b, - vecType const& z, U c, - vecType const& w, U d + vec const& x, U a, + vec const& y, U b, + vec const& z, U c, + vec const& w, U d ) { - vecType Result; + vec Result; for(length_t i = 0, n = Result.length(); i < n; ++i) { T Test1 = max(x[i], y[i]); diff --git a/glm/gtx/bit.hpp b/glm/gtx/bit.hpp index 15bfe5d6..b883a664 100644 --- a/glm/gtx/bit.hpp +++ b/glm/gtx/bit.hpp @@ -39,8 +39,8 @@ namespace glm /// 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); + template + GLM_FUNC_DECL vec highestBitValue(vec const& value); /// Return the power of two number which value is just higher the input value. /// Deprecated, use ceilPowerOfTwo from GTC_round instead @@ -55,8 +55,8 @@ namespace glm /// /// @see gtc_round /// @see gtx_bit - template class vecType> - GLM_DEPRECATED GLM_FUNC_DECL vecType powerOfTwoAbove(vecType const & value); + template + GLM_DEPRECATED GLM_FUNC_DECL vec powerOfTwoAbove(vec const& value); /// Return the power of two number which value is just lower the input value. /// Deprecated, use floorPowerOfTwo from GTC_round instead @@ -71,8 +71,8 @@ namespace glm /// /// @see gtc_round /// @see gtx_bit - template class vecType> - GLM_DEPRECATED GLM_FUNC_DECL vecType powerOfTwoBelow(vecType const & value); + template + GLM_DEPRECATED GLM_FUNC_DECL vec powerOfTwoBelow(vec const& value); /// Return the power of two number which value is the closet to the input value. /// Deprecated, use roundPowerOfTwo from GTC_round instead @@ -87,8 +87,8 @@ namespace glm /// /// @see gtc_round /// @see gtx_bit - template class vecType> - GLM_DEPRECATED GLM_FUNC_DECL vecType powerOfTwoNearest(vecType const & value); + template + GLM_DEPRECATED GLM_FUNC_DECL vec powerOfTwoNearest(vec const& value); /// @} } //namespace glm diff --git a/glm/gtx/bit.inl b/glm/gtx/bit.inl index ff7530c4..fa3b1e09 100644 --- a/glm/gtx/bit.inl +++ b/glm/gtx/bit.inl @@ -19,8 +19,8 @@ namespace glm return result; } - template class vecType> - GLM_FUNC_QUALIFIER vecType highestBitValue(vecType const & v) + template + GLM_FUNC_QUALIFIER vec highestBitValue(vec const & v) { return detail::functor1::call(highestBitValue, v); } @@ -34,8 +34,8 @@ namespace glm return (Value & (~Value + 1)); } - template class vecType> - GLM_FUNC_QUALIFIER vecType lowestBitValue(vecType const & v) + template + GLM_FUNC_QUALIFIER vec lowestBitValue(vec const& v) { return detail::functor1::call(lowestBitValue, v); } @@ -49,8 +49,8 @@ namespace glm return isPowerOfTwo(value) ? value : highestBitValue(value) << 1; } - template class vecType> - GLM_FUNC_QUALIFIER vecType powerOfTwoAbove(vecType const & v) + template + GLM_FUNC_QUALIFIER vec powerOfTwoAbove(vec const& v) { return detail::functor1::call(powerOfTwoAbove, v); } @@ -64,8 +64,8 @@ namespace glm return isPowerOfTwo(value) ? value : highestBitValue(value); } - template class vecType> - GLM_FUNC_QUALIFIER vecType powerOfTwoBelow(vecType const & v) + template + GLM_FUNC_QUALIFIER vec powerOfTwoBelow(vec const& v) { return detail::functor1::call(powerOfTwoBelow, v); } @@ -84,8 +84,8 @@ namespace glm return (next - value) < (value - prev) ? next : prev; } - template class vecType> - GLM_FUNC_QUALIFIER vecType powerOfTwoNearest(vecType const & v) + template + GLM_FUNC_QUALIFIER vec powerOfTwoNearest(vec const& v) { return detail::functor1::call(powerOfTwoNearest, v); } diff --git a/glm/gtx/closest_point.hpp b/glm/gtx/closest_point.hpp index a8433360..d4b8ed38 100644 --- a/glm/gtx/closest_point.hpp +++ b/glm/gtx/closest_point.hpp @@ -30,14 +30,14 @@ namespace glm /// Find the point on a straight line which is the closet of a point. /// @see gtx_closest_point - template + template GLM_FUNC_DECL vec<3, T, P> closestPointOnLine( vec<3, T, P> const & point, vec<3, T, P> const & a, vec<3, T, P> const & b); /// 2d lines work as well - template + template GLM_FUNC_DECL vec<2, T, P> closestPointOnLine( vec<2, T, P> const & point, vec<2, T, P> const & a, diff --git a/glm/gtx/closest_point.inl b/glm/gtx/closest_point.inl index fdbc9373..967d2a23 100644 --- a/glm/gtx/closest_point.inl +++ b/glm/gtx/closest_point.inl @@ -3,7 +3,7 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER vec<3, T, P> closestPointOnLine ( vec<3, T, P> const & point, @@ -23,7 +23,7 @@ namespace glm return a + LineDirection * Distance; } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> closestPointOnLine ( vec<2, T, P> const & point, diff --git a/glm/gtx/color_encoding.hpp b/glm/gtx/color_encoding.hpp index 0994e283..40cc8234 100644 --- a/glm/gtx/color_encoding.hpp +++ b/glm/gtx/color_encoding.hpp @@ -15,7 +15,7 @@ // Dependencies #include "../detail/setup.hpp" -#include "../detail/precision.hpp" +#include "../detail/qualifier.hpp" #include "../vec3.hpp" #include @@ -29,19 +29,19 @@ namespace glm /// @{ /// Convert a linear sRGB color to D65 YUV. - template + template GLM_FUNC_DECL vec<3, T, P> convertLinearSRGBToD65XYZ(vec<3, T, P> const& ColorLinearSRGB); /// Convert a linear sRGB color to D50 YUV. - template + template GLM_FUNC_DECL vec<3, T, P> convertLinearSRGBToD50XYZ(vec<3, T, P> const& ColorLinearSRGB); /// Convert a D65 YUV color to linear sRGB. - template + template GLM_FUNC_DECL vec<3, T, P> convertD65XYZToLinearSRGB(vec<3, T, P> const& ColorD65XYZ); /// Convert a D65 YUV color to D50 YUV. - template + template GLM_FUNC_DECL vec<3, T, P> convertD65XYZToD50XYZ(vec<3, T, P> const& ColorD65XYZ); /// @} diff --git a/glm/gtx/color_encoding.inl b/glm/gtx/color_encoding.inl index ad82dc52..aef01ef1 100644 --- a/glm/gtx/color_encoding.inl +++ b/glm/gtx/color_encoding.inl @@ -3,7 +3,7 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER vec<3, T, P> convertLinearSRGBToD65XYZ(vec<3, T, P> const& ColorLinearSRGB) { vec<3, T, P> const M(0.490f, 0.17697f, 0.2f); @@ -13,7 +13,7 @@ namespace glm return (M * ColorLinearSRGB + N * ColorLinearSRGB + O * ColorLinearSRGB) * static_cast(5.650675255693055f); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> convertLinearSRGBToD50XYZ(vec<3, T, P> const& ColorLinearSRGB) { vec<3, T, P> const M(0.436030342570117f, 0.222438466210245f, 0.013897440074263f); @@ -23,7 +23,7 @@ namespace glm return M * ColorLinearSRGB + N * ColorLinearSRGB + O * ColorLinearSRGB; } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> convertD65XYZToLinearSRGB(vec<3, T, P> const& ColorD65XYZ) { vec<3, T, P> const M(0.41847f, -0.091169f, 0.0009209f); @@ -33,7 +33,7 @@ namespace glm return M * ColorD65XYZ + N * ColorD65XYZ + O * ColorD65XYZ; } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> convertD65XYZToD50XYZ(vec<3, T, P> const& ColorD65XYZ) { vec<3, T, P> const M(+1.047844353856414f, +0.029549007606644f, -0.009250984365223f); diff --git a/glm/gtx/color_space.hpp b/glm/gtx/color_space.hpp index 04ff13e6..d084c5d0 100644 --- a/glm/gtx/color_space.hpp +++ b/glm/gtx/color_space.hpp @@ -30,13 +30,13 @@ namespace glm /// Converts a color from HSV color space to its color in RGB color space. /// @see gtx_color_space - template + template GLM_FUNC_DECL vec<3, T, P> rgbColor( vec<3, T, P> const & hsvValue); /// Converts a color from RGB color space to its color in HSV color space. /// @see gtx_color_space - template + template GLM_FUNC_DECL vec<3, T, P> hsvColor( vec<3, T, P> const & rgbValue); @@ -48,21 +48,21 @@ namespace glm /// Modify the saturation of a color. /// @see gtx_color_space - template + template GLM_FUNC_DECL vec<3, T, P> saturation( T const s, vec<3, T, P> const & color); /// Modify the saturation of a color. /// @see gtx_color_space - template + template GLM_FUNC_DECL vec<4, T, P> saturation( T const s, vec<4, T, P> const & color); /// Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals. /// @see gtx_color_space - template + template GLM_FUNC_DECL T luminosity( vec<3, T, P> const & color); diff --git a/glm/gtx/color_space.inl b/glm/gtx/color_space.inl index 09fc9f65..af19f02a 100644 --- a/glm/gtx/color_space.inl +++ b/glm/gtx/color_space.inl @@ -3,7 +3,7 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER vec<3, T, P> rgbColor(const vec<3, T, P>& hsvColor) { vec<3, T, P> hsv = hsvColor; @@ -60,7 +60,7 @@ namespace glm return rgbColor; } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> hsvColor(const vec<3, T, P>& rgbColor) { vec<3, T, P> hsv = rgbColor; @@ -121,19 +121,19 @@ namespace glm return result; } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> saturation(const T s, const vec<3, T, P>& color) { return vec<3, T, P>(saturation(s) * vec<4, T, P>(color, T(0))); } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> saturation(const T s, const vec<4, T, P>& color) { return saturation(s) * color; } - template + template GLM_FUNC_QUALIFIER T luminosity(const vec<3, T, P>& color) { const vec<3, T, P> tmp = vec<3, T, P>(0.33, 0.59, 0.11); diff --git a/glm/gtx/color_space_YCoCg.hpp b/glm/gtx/color_space_YCoCg.hpp index 0ac1dc36..e1235695 100644 --- a/glm/gtx/color_space_YCoCg.hpp +++ b/glm/gtx/color_space_YCoCg.hpp @@ -30,27 +30,27 @@ namespace glm /// Convert a color from RGB color space to YCoCg color space. /// @see gtx_color_space_YCoCg - template + template GLM_FUNC_DECL vec<3, T, P> rgb2YCoCg( vec<3, T, P> const & rgbColor); /// Convert a color from YCoCg color space to RGB color space. /// @see gtx_color_space_YCoCg - template + template GLM_FUNC_DECL vec<3, T, P> YCoCg2rgb( vec<3, T, P> 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 + template GLM_FUNC_DECL vec<3, T, P> rgb2YCoCgR( vec<3, T, P> 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 + template GLM_FUNC_DECL vec<3, T, P> YCoCgR2rgb( vec<3, T, P> const & YCoCgColor); diff --git a/glm/gtx/color_space_YCoCg.inl b/glm/gtx/color_space_YCoCg.inl index 62b04417..925a8477 100644 --- a/glm/gtx/color_space_YCoCg.inl +++ b/glm/gtx/color_space_YCoCg.inl @@ -3,7 +3,7 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER vec<3, T, P> rgb2YCoCg ( vec<3, T, P> const & rgbColor @@ -16,7 +16,7 @@ namespace glm return result; } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> YCoCg2rgb ( vec<3, T, P> const & YCoCgColor @@ -29,7 +29,7 @@ namespace glm return result; } - template + template class compute_YCoCgR { public: static GLM_FUNC_QUALIFIER vec<3, T, P> rgb2YCoCgR @@ -58,7 +58,7 @@ namespace glm } }; - template + template class compute_YCoCgR { public: static GLM_FUNC_QUALIFIER vec<3, T, P> rgb2YCoCgR @@ -88,7 +88,7 @@ namespace glm } }; - template + template GLM_FUNC_QUALIFIER vec<3, T, P> rgb2YCoCgR ( vec<3, T, P> const & rgbColor @@ -97,7 +97,7 @@ namespace glm return compute_YCoCgR::is_integer>::rgb2YCoCgR(rgbColor); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> YCoCgR2rgb ( vec<3, T, P> const & YCoCgRColor diff --git a/glm/gtx/common.hpp b/glm/gtx/common.hpp index f3366dd0..fe1af0cc 100644 --- a/glm/gtx/common.hpp +++ b/glm/gtx/common.hpp @@ -47,8 +47,8 @@ namespace glm /// /// @see GLSL mod vs HLSL fmod /// @see GLSL mod man page - template class vecType> - GLM_FUNC_DECL vecType fmod(vecType const & v); + template + GLM_FUNC_DECL vec fmod(vec const & v); /// @} }//namespace glm diff --git a/glm/gtx/common.inl b/glm/gtx/common.inl index 5e78905b..64eb254a 100644 --- a/glm/gtx/common.inl +++ b/glm/gtx/common.inl @@ -8,19 +8,19 @@ namespace glm{ namespace detail { - template class vecType, bool isFloat = true> + template struct compute_fmod { - GLM_FUNC_QUALIFIER static vecType call(vecType const & a, vecType const & b) + GLM_FUNC_QUALIFIER static vec call(vec const & a, vec const & b) { return detail::functor2::call(std::fmod, a, b); } }; - template class vecType> - struct compute_fmod + template + struct compute_fmod { - GLM_FUNC_QUALIFIER static vecType call(vecType const & a, vecType const & b) + GLM_FUNC_QUALIFIER static vec call(vec const & a, vec const & b) { return a % b; } @@ -39,7 +39,7 @@ namespace detail # endif } - template + template GLM_FUNC_QUALIFIER typename vec<1, T, P>::bool_type isdenormal ( vec<1, T, P> const & x @@ -51,7 +51,7 @@ namespace detail isdenormal(x.x)); } - template + template GLM_FUNC_QUALIFIER typename vec<2, T, P>::bool_type isdenormal ( vec<2, T, P> const & x @@ -64,7 +64,7 @@ namespace detail isdenormal(x.y)); } - template + template GLM_FUNC_QUALIFIER typename vec<3, T, P>::bool_type isdenormal ( vec<3, T, P> const & x @@ -78,7 +78,7 @@ namespace detail isdenormal(x.z)); } - template + template GLM_FUNC_QUALIFIER typename vec<4, T, P>::bool_type isdenormal ( vec<4, T, P> const & x @@ -100,15 +100,15 @@ namespace detail return fmod(vec<1, genType>(x), y).x; } - template class vecType> - GLM_FUNC_QUALIFIER vecType fmod(vecType const & x, T y) + template + GLM_FUNC_QUALIFIER vec fmod(vec const & x, T y) { - return detail::compute_fmod::is_iec559>::call(x, vecType(y)); + return detail::compute_fmod::is_iec559>::call(x, vec(y)); } - template class vecType> - GLM_FUNC_QUALIFIER vecType fmod(vecType const & x, vecType const & y) + template + GLM_FUNC_QUALIFIER vec fmod(vec const & x, vec const & y) { - return detail::compute_fmod::is_iec559>::call(x, y); + return detail::compute_fmod::is_iec559>::call(x, y); } }//namespace glm diff --git a/glm/gtx/compatibility.hpp b/glm/gtx/compatibility.hpp index e11f7394..6208a303 100644 --- a/glm/gtx/compatibility.hpp +++ b/glm/gtx/compatibility.hpp @@ -39,29 +39,29 @@ namespace glm /// @{ 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 vec<2, T, P> lerp(const vec<2, T, P>& x, const vec<2, T, P>& 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 vec<2, T, P> lerp(const vec<2, T, P>& x, const vec<2, T, P>& 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 vec<3, T, P> lerp(const vec<3, T, P>& x, const vec<3, T, P>& 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 vec<4, T, P> lerp(const vec<4, T, P>& x, const vec<4, T, P>& 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 vec<2, T, P> lerp(const vec<2, T, P>& x, const vec<2, T, P>& y, const vec<2, T, P>& 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 vec<3, T, P> lerp(const vec<3, T, P>& x, const vec<3, T, P>& y, const vec<3, T, P>& 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 vec<4, T, P> lerp(const vec<4, T, P>& x, const vec<4, T, P>& y, const vec<4, T, P>& 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 vec<3, T, P> lerp(const vec<3, T, P>& x, const vec<3, T, P>& 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 vec<4, T, P> lerp(const vec<4, T, P>& x, const vec<4, T, P>& 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 vec<2, T, P> lerp(const vec<2, T, P>& x, const vec<2, T, P>& y, const vec<2, T, P>& 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 vec<3, T, P> lerp(const vec<3, T, P>& x, const vec<3, T, P>& y, const vec<3, T, P>& 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 vec<4, T, P> lerp(const vec<4, T, P>& x, const vec<4, T, P>& y, const vec<4, T, P>& 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 vec<2, T, P> saturate(const vec<2, T, P>& 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 vec<3, T, P> saturate(const vec<3, T, P>& 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 vec<4, T, P> saturate(const vec<4, T, P>& 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 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 vec<2, T, P> saturate(const vec<2, T, P>& 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 vec<3, T, P> saturate(const vec<3, T, P>& 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 vec<4, T, P> saturate(const vec<4, T, P>& 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 vec<2, T, P> atan2(const vec<2, T, P>& x, const vec<2, T, P>& 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 vec<3, T, P> atan2(const vec<3, T, P>& x, const vec<3, T, P>& 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 vec<4, T, P> atan2(const vec<4, T, P>& x, const vec<4, T, P>& 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 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 vec<2, T, P> atan2(const vec<2, T, P>& x, const vec<2, T, P>& 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 vec<3, T, P> atan2(const vec<3, T, P>& x, const vec<3, T, P>& 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 vec<4, T, P> atan2(const vec<4, T, P>& x, const vec<4, T, P>& 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 vec<1, bool, P> isfinite(const vec<1, T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) - template GLM_FUNC_DECL vec<2, bool, P> isfinite(const vec<2, T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) - template GLM_FUNC_DECL vec<3, bool, P> isfinite(const vec<3, T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) - template GLM_FUNC_DECL vec<4, bool, P> isfinite(const vec<4, T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) + template GLM_FUNC_DECL vec<1, bool, P> isfinite(const vec<1, T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) + template GLM_FUNC_DECL vec<2, bool, P> isfinite(const vec<2, T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) + template GLM_FUNC_DECL vec<3, bool, P> isfinite(const vec<3, T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) + template GLM_FUNC_DECL vec<4, bool, P> isfinite(const vec<4, T, P>& 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 vec<2, bool, highp> bool2; //!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension) @@ -95,37 +95,37 @@ namespace glm typedef mat<4, 3, int, highp> int4x3; //!< \brief integer matrix with 4 x 3 components. (From GLM_GTX_compatibility extension) typedef mat<4, 4, int, highp> 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 vec<2, float, highp> float2; //!< \brief single-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension) - typedef vec<3, float, highp> float3; //!< \brief single-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension) - typedef vec<4, float, highp> float4; //!< \brief single-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension) + typedef float float1; //!< \brief single-qualifier floating-point vector with 1 component. (From GLM_GTX_compatibility extension) + typedef vec<2, float, highp> float2; //!< \brief single-qualifier floating-point vector with 2 components. (From GLM_GTX_compatibility extension) + typedef vec<3, float, highp> float3; //!< \brief single-qualifier floating-point vector with 3 components. (From GLM_GTX_compatibility extension) + typedef vec<4, float, highp> float4; //!< \brief single-qualifier 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 mat<2, 2, float, highp> float2x2; //!< \brief single-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension) - typedef mat<2, 3, float, highp> float2x3; //!< \brief single-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension) - typedef mat<2, 4, float, highp> float2x4; //!< \brief single-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension) - typedef mat<3, 2, float, highp> float3x2; //!< \brief single-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension) - typedef mat<3, 3, float, highp> float3x3; //!< \brief single-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension) - typedef mat<3, 4, float, highp> float3x4; //!< \brief single-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension) - typedef mat<4, 2, float, highp> float4x2; //!< \brief single-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension) - typedef mat<4, 3, float, highp> float4x3; //!< \brief single-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension) - typedef mat<4, 4, float, highp> float4x4; //!< \brief single-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension) + typedef float float1x1; //!< \brief single-qualifier floating-point matrix with 1 component. (From GLM_GTX_compatibility extension) + typedef mat<2, 2, float, highp> float2x2; //!< \brief single-qualifier floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension) + typedef mat<2, 3, float, highp> float2x3; //!< \brief single-qualifier floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension) + typedef mat<2, 4, float, highp> float2x4; //!< \brief single-qualifier floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension) + typedef mat<3, 2, float, highp> float3x2; //!< \brief single-qualifier floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension) + typedef mat<3, 3, float, highp> float3x3; //!< \brief single-qualifier floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension) + typedef mat<3, 4, float, highp> float3x4; //!< \brief single-qualifier floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension) + typedef mat<4, 2, float, highp> float4x2; //!< \brief single-qualifier floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension) + typedef mat<4, 3, float, highp> float4x3; //!< \brief single-qualifier floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension) + typedef mat<4, 4, float, highp> float4x4; //!< \brief single-qualifier 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 vec<2, double, highp> double2; //!< \brief double-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension) - typedef vec<3, double, highp> double3; //!< \brief double-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension) - typedef vec<4, double, highp> double4; //!< \brief double-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension) + typedef double double1; //!< \brief double-qualifier floating-point vector with 1 component. (From GLM_GTX_compatibility extension) + typedef vec<2, double, highp> double2; //!< \brief double-qualifier floating-point vector with 2 components. (From GLM_GTX_compatibility extension) + typedef vec<3, double, highp> double3; //!< \brief double-qualifier floating-point vector with 3 components. (From GLM_GTX_compatibility extension) + typedef vec<4, double, highp> double4; //!< \brief double-qualifier 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 mat<2, 2, double, highp> double2x2; //!< \brief double-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension) - typedef mat<2, 3, double, highp> double2x3; //!< \brief double-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension) - typedef mat<2, 4, double, highp> double2x4; //!< \brief double-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension) - typedef mat<3, 2, double, highp> double3x2; //!< \brief double-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension) - typedef mat<3, 3, double, highp> double3x3; //!< \brief double-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension) - typedef mat<3, 4, double, highp> double3x4; //!< \brief double-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension) - typedef mat<4, 2, double, highp> double4x2; //!< \brief double-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension) - typedef mat<4, 3, double, highp> double4x3; //!< \brief double-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension) - typedef mat<4, 4, double, highp> double4x4; //!< \brief double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension) + typedef double double1x1; //!< \brief double-qualifier floating-point matrix with 1 component. (From GLM_GTX_compatibility extension) + typedef mat<2, 2, double, highp> double2x2; //!< \brief double-qualifier floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension) + typedef mat<2, 3, double, highp> double2x3; //!< \brief double-qualifier floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension) + typedef mat<2, 4, double, highp> double2x4; //!< \brief double-qualifier floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension) + typedef mat<3, 2, double, highp> double3x2; //!< \brief double-qualifier floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension) + typedef mat<3, 3, double, highp> double3x3; //!< \brief double-qualifier floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension) + typedef mat<3, 4, double, highp> double3x4; //!< \brief double-qualifier floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension) + typedef mat<4, 2, double, highp> double4x2; //!< \brief double-qualifier floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension) + typedef mat<4, 3, double, highp> double4x3; //!< \brief double-qualifier floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension) + typedef mat<4, 4, double, highp> double4x4; //!< \brief double-qualifier floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension) /// @} }//namespace glm diff --git a/glm/gtx/compatibility.inl b/glm/gtx/compatibility.inl index cf1c07a1..bcbfc3e1 100644 --- a/glm/gtx/compatibility.inl +++ b/glm/gtx/compatibility.inl @@ -24,7 +24,7 @@ namespace glm # endif } - template + template GLM_FUNC_QUALIFIER vec<1, bool, P> isfinite( vec<1, T, P> const & x) { @@ -32,7 +32,7 @@ namespace glm isfinite(x.x)); } - template + template GLM_FUNC_QUALIFIER vec<2, bool, P> isfinite( vec<2, T, P> const & x) { @@ -41,7 +41,7 @@ namespace glm isfinite(x.y)); } - template + template GLM_FUNC_QUALIFIER vec<3, bool, P> isfinite( vec<3, T, P> const & x) { @@ -51,7 +51,7 @@ namespace glm isfinite(x.z)); } - template + template GLM_FUNC_QUALIFIER vec<4, bool, P> isfinite( vec<4, T, P> const & x) { diff --git a/glm/gtx/component_wise.hpp b/glm/gtx/component_wise.hpp index 3b35ad19..91a64823 100644 --- a/glm/gtx/component_wise.hpp +++ b/glm/gtx/component_wise.hpp @@ -16,7 +16,7 @@ // Dependencies #include "../detail/setup.hpp" -#include "../detail/precision.hpp" +#include "../detail/qualifier.hpp" #ifndef GLM_ENABLE_EXPERIMENTAL # error "GLM: GLM_GTX_component_wise is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." @@ -32,16 +32,16 @@ namespace glm /// @{ /// 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. + /// If the parameter value type is already a floating qualifier type, the value is passed through. /// @see gtx_component_wise - template class vecType> - GLM_FUNC_DECL vecType compNormalize(vecType const & v); + template + GLM_FUNC_DECL vec compNormalize(vec 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. + /// If the parameter value type is already a floating qualifier type, the value is passed through. /// @see gtx_component_wise - template class vecType> - GLM_FUNC_DECL vecType compScale(vecType const & v); + template + GLM_FUNC_DECL vec compScale(vec const & v); /// Add all vector components together. /// @see gtx_component_wise diff --git a/glm/gtx/component_wise.inl b/glm/gtx/component_wise.inl index 3961f3cd..5fde73d2 100644 --- a/glm/gtx/component_wise.inl +++ b/glm/gtx/component_wise.inl @@ -6,92 +6,92 @@ namespace glm{ namespace detail { - template class vecType, bool isInteger, bool signedType> + template struct compute_compNormalize {}; - template class vecType> - struct compute_compNormalize + template + struct compute_compNormalize { - GLM_FUNC_QUALIFIER static vecType call(vecType const & v) + GLM_FUNC_QUALIFIER static vec call(vec 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); + return (vec(v) - Min) / (Max - Min) * static_cast(2) - static_cast(1); } }; - template class vecType> - struct compute_compNormalize + template + struct compute_compNormalize { - GLM_FUNC_QUALIFIER static vecType call(vecType const & v) + GLM_FUNC_QUALIFIER static vec call(vec const & v) { - return vecType(v) / static_cast(std::numeric_limits::max()); + return vec(v) / static_cast(std::numeric_limits::max()); } }; - template class vecType> - struct compute_compNormalize + template + struct compute_compNormalize { - GLM_FUNC_QUALIFIER static vecType call(vecType const & v) + GLM_FUNC_QUALIFIER static vec call(vec const& v) { return v; } }; - template class vecType, bool isInteger, bool signedType> + template struct compute_compScale {}; - template class vecType> - struct compute_compScale + template + struct compute_compScale { - GLM_FUNC_QUALIFIER static vecType call(vecType const & v) + GLM_FUNC_QUALIFIER static vec call(vec 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)); + vec const Scaled(v * Max); + vec const Result(Scaled - static_cast(0.5)); return Result; } }; - template class vecType> - struct compute_compScale + template + struct compute_compScale { - GLM_FUNC_QUALIFIER static vecType call(vecType const & v) + GLM_FUNC_QUALIFIER static vec call(vec const & v) { - return vecType(vecType(v) * static_cast(std::numeric_limits::max())); + return vec(vec(v) * static_cast(std::numeric_limits::max())); } }; - template class vecType> - struct compute_compScale + template + struct compute_compScale { - GLM_FUNC_QUALIFIER static vecType call(vecType const & v) + GLM_FUNC_QUALIFIER static vec call(vec const & v) { return v; } }; }//namespace detail - template class vecType> - GLM_FUNC_QUALIFIER vecType compNormalize(vecType const & v) + template + GLM_FUNC_QUALIFIER vec compNormalize(vec 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); + return detail::compute_compNormalize::is_integer, std::numeric_limits::is_signed>::call(v); } - template class vecType> - GLM_FUNC_QUALIFIER vecType compScale(vecType const & v) + template + GLM_FUNC_QUALIFIER vec compScale(vec 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); + return detail::compute_compScale::is_integer, std::numeric_limits::is_signed>::call(v); } - template class vecType> - GLM_FUNC_QUALIFIER T compAdd(vecType const & v) + template + GLM_FUNC_QUALIFIER T compAdd(vec const& v) { T Result(0); for(length_t i = 0, n = v.length(); i < n; ++i) @@ -99,8 +99,8 @@ namespace detail return Result; } - template class vecType> - GLM_FUNC_QUALIFIER T compMul(vecType const & v) + template + GLM_FUNC_QUALIFIER T compMul(vec const & v) { T Result(1); for(length_t i = 0, n = v.length(); i < n; ++i) @@ -108,8 +108,8 @@ namespace detail return Result; } - template class vecType> - GLM_FUNC_QUALIFIER T compMin(vecType const & v) + template + GLM_FUNC_QUALIFIER T compMin(vec const & v) { T Result(v[0]); for(length_t i = 1, n = v.length(); i < n; ++i) @@ -117,8 +117,8 @@ namespace detail return Result; } - template class vecType> - GLM_FUNC_QUALIFIER T compMax(vecType const & v) + template + GLM_FUNC_QUALIFIER T compMax(vec const & v) { T Result(v[0]); for(length_t i = 1, n = v.length(); i < n; ++i) diff --git a/glm/gtx/dual_quaternion.hpp b/glm/gtx/dual_quaternion.hpp index b7cc311c..b49bf0e1 100644 --- a/glm/gtx/dual_quaternion.hpp +++ b/glm/gtx/dual_quaternion.hpp @@ -33,7 +33,7 @@ namespace glm /// @addtogroup gtx_dual_quaternion /// @{ - template + template struct tdualquat { // -- Implementation detail -- @@ -58,7 +58,7 @@ namespace glm GLM_FUNC_DECL GLM_CONSTEXPR tdualquat() GLM_DEFAULT; GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tdualquat const & d) GLM_DEFAULT; - template + template GLM_FUNC_DECL GLM_CONSTEXPR tdualquat(tdualquat const & d); // -- Explicit basic constructors -- @@ -69,7 +69,7 @@ namespace glm // -- Conversion constructors -- - template + template GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tdualquat(tdualquat const & q); GLM_FUNC_DECL GLM_EXPLICIT tdualquat(mat<2, 4, T, P> const & holder_mat); @@ -89,141 +89,141 @@ namespace glm // -- Unary bit operators -- - template + template GLM_FUNC_DECL tdualquat operator+(tdualquat const & q); - template + template GLM_FUNC_DECL tdualquat operator-(tdualquat const & q); // -- Binary operators -- - template + template GLM_FUNC_DECL tdualquat operator+(tdualquat const & q, tdualquat const & p); - template + template GLM_FUNC_DECL tdualquat operator*(tdualquat const & q, tdualquat const & p); - template + template GLM_FUNC_DECL vec<3, T, P> operator*(tdualquat const & q, vec<3, T, P> const & v); - template + template GLM_FUNC_DECL vec<3, T, P> operator*(vec<3, T, P> const & v, tdualquat const & q); - template + template GLM_FUNC_DECL vec<4, T, P> operator*(tdualquat const & q, vec<4, T, P> const & v); - template + template GLM_FUNC_DECL vec<4, T, P> operator*(vec<4, T, P> const & v, tdualquat const & q); - template + template GLM_FUNC_DECL tdualquat operator*(tdualquat const & q, T const & s); - template + template GLM_FUNC_DECL tdualquat operator*(T const & s, tdualquat const & q); - template + template GLM_FUNC_DECL tdualquat operator/(tdualquat const & q, T const & s); // -- Boolean operators -- - template + template GLM_FUNC_DECL bool operator==(tdualquat const & q1, tdualquat const & q2); - template + template GLM_FUNC_DECL bool operator!=(tdualquat const & q1, tdualquat const & q2); /// Creates an identity dual quaternion. /// /// @see gtx_dual_quaternion - template + template GLM_FUNC_DECL tdualquat dual_quat_identity(); /// Returns the normalized quaternion. /// /// @see gtx_dual_quaternion - template + template GLM_FUNC_DECL tdualquat normalize(tdualquat const & q); /// Returns the linear interpolation of two dual quaternion. /// /// @see gtc_dual_quaternion - template + template GLM_FUNC_DECL tdualquat lerp(tdualquat const & x, tdualquat const & y, T const & a); /// Returns the q inverse. /// /// @see gtx_dual_quaternion - template + template GLM_FUNC_DECL tdualquat inverse(tdualquat const & q); /// Converts a quaternion to a 2 * 4 matrix. /// /// @see gtx_dual_quaternion - template + template GLM_FUNC_DECL mat<2, 4, T, P> mat2x4_cast(tdualquat const & x); /// Converts a quaternion to a 3 * 4 matrix. /// /// @see gtx_dual_quaternion - template + template GLM_FUNC_DECL mat<3, 4, T, P> 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 + template GLM_FUNC_DECL tdualquat dualquat_cast(mat<2, 4, T, P> const & x); /// Converts a 3 * 4 matrix (augmented matrix rotation + translation) to a quaternion. /// /// @see gtx_dual_quaternion - template + template GLM_FUNC_DECL tdualquat dualquat_cast(mat<3, 4, T, P> const & x); - /// Dual-quaternion of low single-precision floating-point numbers. + /// Dual-quaternion of low single-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat lowp_dualquat; - /// Dual-quaternion of medium single-precision floating-point numbers. + /// Dual-quaternion of medium single-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat mediump_dualquat; - /// Dual-quaternion of high single-precision floating-point numbers. + /// Dual-quaternion of high single-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat highp_dualquat; - /// Dual-quaternion of low single-precision floating-point numbers. + /// Dual-quaternion of low single-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat lowp_fdualquat; - /// Dual-quaternion of medium single-precision floating-point numbers. + /// Dual-quaternion of medium single-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat mediump_fdualquat; - /// Dual-quaternion of high single-precision floating-point numbers. + /// Dual-quaternion of high single-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat highp_fdualquat; - /// Dual-quaternion of low double-precision floating-point numbers. + /// Dual-quaternion of low double-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat lowp_ddualquat; - /// Dual-quaternion of medium double-precision floating-point numbers. + /// Dual-quaternion of medium double-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat mediump_ddualquat; - /// Dual-quaternion of high double-precision floating-point numbers. + /// Dual-quaternion of high double-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef tdualquat highp_ddualquat; @@ -235,7 +235,7 @@ namespace glm /// @see gtx_dual_quaternion typedef highp_fdualquat dualquat; - /// Dual-quaternion of single-precision floating-point numbers. + /// Dual-quaternion of single-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef highp_fdualquat fdualquat; @@ -254,7 +254,7 @@ namespace glm #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. + /// Dual-quaternion of default double-qualifier floating-point numbers. /// /// @see gtx_dual_quaternion typedef highp_ddualquat ddualquat; diff --git a/glm/gtx/dual_quaternion.inl b/glm/gtx/dual_quaternion.inl index 9e4b8cf9..a2af4898 100644 --- a/glm/gtx/dual_quaternion.inl +++ b/glm/gtx/dual_quaternion.inl @@ -8,14 +8,14 @@ namespace glm { // -- Component accesses -- - template + 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 + template GLM_FUNC_QUALIFIER typename tdualquat::part_type const & tdualquat::operator[](typename tdualquat::length_type i) const { assert(i >= 0 && i < this->length()); @@ -25,21 +25,21 @@ namespace glm // -- Implicit basic constructors -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat() {} # endif # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(tdualquat const & d) : real(d.real) , dual(d.dual) {} # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(tdualquat const & d) : real(d.real) , dual(d.dual) @@ -47,12 +47,12 @@ namespace glm // -- Explicit basic constructors -- - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(tquat const & r) : real(r), dual(tquat(0, 0, 0, 0)) {} - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(tquat const & q, vec<3, T, P> const& p) : real(q), dual( T(-0.5) * ( p.x*q.x + p.y*q.y + p.z*q.z), @@ -61,27 +61,27 @@ namespace glm T(+0.5) * ( p.x*q.y - p.y*q.x + p.z*q.w)) {} - template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(tquat const & r, tquat const & d) : real(r), dual(d) {} // -- Conversion constructors -- - template - template + template + template GLM_FUNC_QUALIFIER GLM_CONSTEXPR tdualquat::tdualquat(tdualquat const & q) : real(q.real) , dual(q.dual) {} - template + template GLM_FUNC_QUALIFIER tdualquat::tdualquat(mat<2, 4, T, P> const & m) { *this = dualquat_cast(m); } - template + template GLM_FUNC_QUALIFIER tdualquat::tdualquat(mat<3, 4, T, P> const & m) { *this = dualquat_cast(m); @@ -90,7 +90,7 @@ namespace glm // -- Unary arithmetic operators -- # if !GLM_HAS_DEFAULTED_FUNCTIONS - template + template GLM_FUNC_QUALIFIER tdualquat & tdualquat::operator=(tdualquat const & q) { this->real = q.real; @@ -99,7 +99,7 @@ namespace glm } # endif//!GLM_HAS_DEFAULTED_FUNCTIONS - template + template template GLM_FUNC_QUALIFIER tdualquat & tdualquat::operator=(tdualquat const & q) { @@ -108,7 +108,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER tdualquat & tdualquat::operator*=(U s) { @@ -117,7 +117,7 @@ namespace glm return *this; } - template + template template GLM_FUNC_QUALIFIER tdualquat & tdualquat::operator/=(U s) { @@ -128,13 +128,13 @@ namespace glm // -- Unary bit operators -- - template + template GLM_FUNC_QUALIFIER tdualquat operator+(tdualquat const & q) { return q; } - template + template GLM_FUNC_QUALIFIER tdualquat operator-(tdualquat const & q) { return tdualquat(-q.real, -q.dual); @@ -142,19 +142,19 @@ namespace glm // -- Binary operators -- - template + template GLM_FUNC_QUALIFIER tdualquat operator+(tdualquat const & q, tdualquat const & p) { return tdualquat(q.real + p.real,q.dual + p.dual); } - template + 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 + template GLM_FUNC_QUALIFIER vec<3, T, P> operator*(tdualquat const & q, vec<3, T, P> const & v) { vec<3, T, P> const real_v3(q.real.x,q.real.y,q.real.z); @@ -162,37 +162,37 @@ namespace glm 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 + template GLM_FUNC_QUALIFIER vec<3, T, P> operator*(vec<3, T, P> const & v, tdualquat const & q) { return glm::inverse(q) * v; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator*(tdualquat const & q, vec<4, T, P> const & v) { return vec<4, T, P>(q * vec<3, T, P>(v), v.w); } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> operator*(vec<4, T, P> const & v, tdualquat const & q) { return glm::inverse(q) * v; } - template + template GLM_FUNC_QUALIFIER tdualquat operator*(tdualquat const & q, T const & s) { return tdualquat(q.real * s, q.dual * s); } - template + template GLM_FUNC_QUALIFIER tdualquat operator*(T const & s, tdualquat const & q) { return q * s; } - template + template GLM_FUNC_QUALIFIER tdualquat operator/(tdualquat const & q, T const & s) { return tdualquat(q.real / s, q.dual / s); @@ -200,13 +200,13 @@ namespace glm // -- Boolean operators -- - template + template GLM_FUNC_QUALIFIER bool operator==(tdualquat const & q1, tdualquat const & q2) { return (q1.real == q2.real) && (q1.dual == q2.dual); } - template + template GLM_FUNC_QUALIFIER bool operator!=(tdualquat const & q1, tdualquat const & q2) { return (q1.real != q2.real) || (q1.dual != q2.dual); @@ -214,7 +214,7 @@ namespace glm // -- Operations -- - template + template GLM_FUNC_QUALIFIER tdualquat dual_quat_identity() { return tdualquat( @@ -222,13 +222,13 @@ namespace glm tquat(static_cast(0), static_cast(0), static_cast(0), static_cast(0))); } - template + template GLM_FUNC_QUALIFIER tdualquat normalize(tdualquat const & q) { return q / length(q.real); } - template + template GLM_FUNC_QUALIFIER tdualquat lerp(tdualquat const & x, tdualquat const & y, T const & a) { // Dual Quaternion Linear blend aka DLB: @@ -240,7 +240,7 @@ namespace glm return tdualquat(x * (one - a) + y * k); } - template + template GLM_FUNC_QUALIFIER tdualquat inverse(tdualquat const & q) { const glm::tquat real = conjugate(q.real); @@ -248,13 +248,13 @@ namespace glm return tdualquat(real, dual + (real * (-2.0f * dot(real,dual)))); } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P> mat2x4_cast(tdualquat const & x) { return mat<2, 4, T, P>( 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 + template GLM_FUNC_QUALIFIER mat<3, 4, T, P> mat3x4_cast(tdualquat const & x) { tquat r = x.real / length2(x.real); @@ -290,7 +290,7 @@ namespace glm return mat<3, 4, T, P>(a, b, c); } - template + template GLM_FUNC_QUALIFIER tdualquat dualquat_cast(mat<2, 4, T, P> const & x) { return tdualquat( @@ -298,7 +298,7 @@ namespace glm tquat( x[1].w, x[1].x, x[1].y, x[1].z )); } - template + template GLM_FUNC_QUALIFIER tdualquat dualquat_cast(mat<3, 4, T, P> const & x) { tquat real; diff --git a/glm/gtx/euler_angles.hpp b/glm/gtx/euler_angles.hpp index 6985faa6..853d1ad4 100644 --- a/glm/gtx/euler_angles.hpp +++ b/glm/gtx/euler_angles.hpp @@ -124,12 +124,12 @@ namespace glm /// Creates a 3D 3 * 3 rotation matrix from euler angles (Y * X * Z). /// @see gtx_euler_angles - template + template GLM_FUNC_DECL mat<3, 3, T, P> orientate3(vec<3, T, P> const & angles); /// Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z). /// @see gtx_euler_angles - template + template GLM_FUNC_DECL mat<4, 4, T, P> orientate4(vec<3, T, P> const & angles); /// Extracts the (X * Y * Z) Euler angles from the rotation matrix M diff --git a/glm/gtx/euler_angles.inl b/glm/gtx/euler_angles.inl index bed37416..fb60718a 100644 --- a/glm/gtx/euler_angles.inl +++ b/glm/gtx/euler_angles.inl @@ -275,7 +275,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> orientate3 ( vec<3, T, P> const & angles @@ -284,7 +284,7 @@ namespace glm return mat<3, 3, T, P>(yawPitchRoll(angles.z, angles.x, angles.y)); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> orientate4 ( vec<3, T, P> const & angles diff --git a/glm/gtx/extend.inl b/glm/gtx/extend.inl index 3939abd4..929d1541 100644 --- a/glm/gtx/extend.inl +++ b/glm/gtx/extend.inl @@ -14,7 +14,7 @@ namespace glm return Origin + (Source - Origin) * Distance; } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> extend ( vec<2, T, P> const & Origin, @@ -25,7 +25,7 @@ namespace glm return Origin + (Source - Origin) * Distance; } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> extend ( vec<3, T, P> const & Origin, @@ -36,7 +36,7 @@ namespace glm return Origin + (Source - Origin) * Distance; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> extend ( vec<4, T, P> const & Origin, diff --git a/glm/gtx/exterior_product.hpp b/glm/gtx/exterior_product.hpp index b7917494..a686df51 100644 --- a/glm/gtx/exterior_product.hpp +++ b/glm/gtx/exterior_product.hpp @@ -15,7 +15,7 @@ // Dependencies #include "../detail/setup.hpp" -#include "../detail/precision.hpp" +#include "../detail/qualifier.hpp" #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED) # pragma message("GLM: GLM_GTX_exterior_product extension included") @@ -31,7 +31,7 @@ namespace glm /// @tparam valType Floating-point scalar types. /// /// @see Exterior product - template + template GLM_FUNC_DECL T cross(vec<2, T, P> const& v, vec<2, T, P> const& u); /// @} diff --git a/glm/gtx/exterior_product.inl b/glm/gtx/exterior_product.inl index fc9376fc..5d269970 100644 --- a/glm/gtx/exterior_product.inl +++ b/glm/gtx/exterior_product.inl @@ -6,7 +6,7 @@ namespace glm { namespace detail { - template + template struct compute_cross_vec2 { GLM_FUNC_QUALIFIER static T call(vec<2, T, P> const& v, vec<2, T, P> const& u) @@ -18,7 +18,7 @@ namespace detail }; }//namespace detail - template + template GLM_FUNC_QUALIFIER T cross(vec<2, T, P> const & x, vec<2, T, P> const & y) { return detail::compute_cross_vec2::value>::call(x, y); diff --git a/glm/gtx/fast_exponential.hpp b/glm/gtx/fast_exponential.hpp index 80822c81..c29edf1d 100644 --- a/glm/gtx/fast_exponential.hpp +++ b/glm/gtx/fast_exponential.hpp @@ -36,8 +36,8 @@ namespace glm /// 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); + template + GLM_FUNC_DECL vec fastPow(vec const & x, vec const & y); /// Faster than the common pow function but less accurate. /// @see gtx_fast_exponential @@ -46,8 +46,8 @@ namespace glm /// Faster than the common pow function but less accurate. /// @see gtx_fast_exponential - template class vecType> - GLM_FUNC_DECL vecType fastPow(vecType const & x); + template + GLM_FUNC_DECL vec fastPow(vec const & x); /// Faster than the common exp function but less accurate. /// @see gtx_fast_exponential @@ -56,8 +56,8 @@ namespace glm /// Faster than the common exp function but less accurate. /// @see gtx_fast_exponential - template class vecType> - GLM_FUNC_DECL vecType fastExp(vecType const & x); + template + GLM_FUNC_DECL vec fastExp(vec const & x); /// Faster than the common log function but less accurate. /// @see gtx_fast_exponential @@ -66,8 +66,8 @@ namespace glm /// Faster than the common exp2 function but less accurate. /// @see gtx_fast_exponential - template class vecType> - GLM_FUNC_DECL vecType fastLog(vecType const & x); + template + GLM_FUNC_DECL vec fastLog(vec const & x); /// Faster than the common exp2 function but less accurate. /// @see gtx_fast_exponential @@ -76,8 +76,8 @@ namespace glm /// Faster than the common exp2 function but less accurate. /// @see gtx_fast_exponential - template class vecType> - GLM_FUNC_DECL vecType fastExp2(vecType const & x); + template + GLM_FUNC_DECL vec fastExp2(vec const & x); /// Faster than the common log2 function but less accurate. /// @see gtx_fast_exponential @@ -86,8 +86,8 @@ namespace glm /// Faster than the common log2 function but less accurate. /// @see gtx_fast_exponential - template class vecType> - GLM_FUNC_DECL vecType fastLog2(vecType const & x); + template + GLM_FUNC_DECL vec fastLog2(vec const & x); /// @} }//namespace glm diff --git a/glm/gtx/fast_exponential.inl b/glm/gtx/fast_exponential.inl index b11c3524..d8f2b700 100644 --- a/glm/gtx/fast_exponential.inl +++ b/glm/gtx/fast_exponential.inl @@ -10,8 +10,8 @@ namespace glm return exp(y * log(x)); } - template class vecType> - GLM_FUNC_QUALIFIER vecType fastPow(vecType const & x, vecType const & y) + template + GLM_FUNC_QUALIFIER vec fastPow(vec const& x, vec const& y) { return exp(y * log(x)); } @@ -25,10 +25,10 @@ namespace glm return f; } - template class vecType> - GLM_FUNC_QUALIFIER vecType fastPow(vecType const & x, vecType const & y) + template + GLM_FUNC_QUALIFIER vec fastPow(vec const & x, vec const & y) { - vecType Result; + vec Result; for(length_t i = 0, n = x.length(); i < n; ++i) Result[i] = fastPow(x[i], y[i]); return Result; @@ -81,8 +81,8 @@ namespace glm } */ - template class vecType> - GLM_FUNC_QUALIFIER vecType fastExp(vecType const & x) + template + GLM_FUNC_QUALIFIER vec fastExp(vec const& x) { return detail::functor1::call(fastExp, x); } @@ -103,8 +103,8 @@ namespace glm } */ - template class vecType> - GLM_FUNC_QUALIFIER vecType fastLog(vecType const & x) + template + GLM_FUNC_QUALIFIER vec fastLog(vec const& x) { return detail::functor1::call(fastLog, x); } @@ -116,8 +116,8 @@ namespace glm return fastExp(0.69314718055994530941723212145818f * x); } - template class vecType> - GLM_FUNC_QUALIFIER vecType fastExp2(vecType const & x) + template + GLM_FUNC_QUALIFIER vec fastExp2(vec const& x) { return detail::functor1::call(fastExp2, x); } @@ -129,8 +129,8 @@ namespace glm return fastLog(x) / 0.69314718055994530941723212145818f; } - template class vecType> - GLM_FUNC_QUALIFIER vecType fastLog2(vecType const & x) + template + GLM_FUNC_QUALIFIER vec fastLog2(vec const& x) { return detail::functor1::call(fastLog2, x); } diff --git a/glm/gtx/fast_square_root.hpp b/glm/gtx/fast_square_root.hpp index 135829b0..8f014b3c 100644 --- a/glm/gtx/fast_square_root.hpp +++ b/glm/gtx/fast_square_root.hpp @@ -41,8 +41,8 @@ namespace glm /// 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); + template + GLM_FUNC_DECL vec fastSqrt(vec const & x); /// Faster than the common inversesqrt function but less accurate. /// @@ -53,8 +53,8 @@ namespace glm /// 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); + template + GLM_FUNC_DECL vec fastInverseSqrt(vec const & x); /// Faster than the common length function but less accurate. /// @@ -65,8 +65,8 @@ namespace glm /// 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); + template + GLM_FUNC_DECL T fastLength(vec const & x); /// Faster than the common distance function but less accurate. /// @@ -77,8 +77,8 @@ namespace glm /// 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); + template + GLM_FUNC_DECL T fastDistance(vec const & x, vec const & y); /// Faster than the common normalize function but less accurate. /// diff --git a/glm/gtx/fast_square_root.inl b/glm/gtx/fast_square_root.inl index c7e6a2c0..3083fd3b 100644 --- a/glm/gtx/fast_square_root.inl +++ b/glm/gtx/fast_square_root.inl @@ -12,8 +12,8 @@ namespace glm return genType(1) / fastInverseSqrt(x); } - template class vecType> - GLM_FUNC_QUALIFIER vecType fastSqrt(vecType const & x) + template + GLM_FUNC_QUALIFIER vec fastSqrt(vec const & x) { return detail::functor1::call(fastSqrt, x); } @@ -30,8 +30,8 @@ namespace glm # endif } - template class vecType> - GLM_FUNC_QUALIFIER vecType fastInverseSqrt(vecType const & x) + template + GLM_FUNC_QUALIFIER vec fastInverseSqrt(vec const & x) { return detail::compute_inversesqrt::value>::call(x); } @@ -45,8 +45,8 @@ namespace glm return abs(x); } - template class vecType> - GLM_FUNC_QUALIFIER T fastLength(vecType const & x) + template + GLM_FUNC_QUALIFIER T fastLength(vec const & x) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'fastLength' only accept floating-point inputs"); @@ -60,8 +60,8 @@ namespace glm return fastLength(y - x); } - template class vecType> - GLM_FUNC_QUALIFIER T fastDistance(vecType const & x, vecType const & y) + template + GLM_FUNC_QUALIFIER T fastDistance(vec const& x, vec const& y) { return fastLength(y - x); } @@ -73,8 +73,8 @@ namespace glm return x > genType(0) ? genType(1) : -genType(1); } - template class vecType> - GLM_FUNC_QUALIFIER vecType fastNormalize(vecType const & x) + template + GLM_FUNC_QUALIFIER vec fastNormalize(vec const& x) { return x * fastInverseSqrt(dot(x, x)); } diff --git a/glm/gtx/fast_trigonometry.inl b/glm/gtx/fast_trigonometry.inl index 200c371b..02739faf 100644 --- a/glm/gtx/fast_trigonometry.inl +++ b/glm/gtx/fast_trigonometry.inl @@ -4,8 +4,8 @@ namespace glm{ namespace detail { - template class vecType> - GLM_FUNC_QUALIFIER vecType taylorCos(vecType const & x) + template + GLM_FUNC_QUALIFIER vec taylorCos(vec const& x) { return static_cast(1) - (x * x) * (1.f / 2.f) @@ -21,8 +21,8 @@ namespace detail 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) + template + GLM_FUNC_QUALIFIER vec cos_52s(vec const& x) { return detail::functor1::call(cos_52s, x); } @@ -35,8 +35,8 @@ namespace detail return abs(mod(angle, two_pi())); } - template class vecType> - GLM_FUNC_QUALIFIER vecType wrapAngle(vecType const & x) + template + GLM_FUNC_QUALIFIER vec wrapAngle(vec const& x) { return detail::functor1::call(wrapAngle, x); } @@ -57,8 +57,8 @@ namespace detail return detail::cos_52s(two_pi() - angle); } - template class vecType> - GLM_FUNC_QUALIFIER vecType fastCos(vecType const & x) + template + GLM_FUNC_QUALIFIER vec fastCos(vec const & x) { return detail::functor1::call(fastCos, x); } @@ -70,8 +70,8 @@ namespace detail return fastCos(half_pi() - x); } - template class vecType> - GLM_FUNC_QUALIFIER vecType fastSin(vecType const & x) + template + GLM_FUNC_QUALIFIER vec fastSin(vec const & x) { return detail::functor1::call(fastSin, x); } @@ -83,8 +83,8 @@ namespace detail 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) + template + GLM_FUNC_QUALIFIER vec fastTan(vec const & x) { return detail::functor1::call(fastTan, x); } @@ -96,8 +96,8 @@ namespace detail 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) + template + GLM_FUNC_QUALIFIER vec fastAsin(vec const & x) { return detail::functor1::call(fastAsin, x); } @@ -109,8 +109,8 @@ namespace detail return T(1.5707963267948966192313216916398) - fastAsin(x); //(PI / 2) } - template class vecType> - GLM_FUNC_QUALIFIER vecType fastAcos(vecType const & x) + template + GLM_FUNC_QUALIFIER vec fastAcos(vec const& x) { return detail::functor1::call(fastAcos, x); } @@ -123,8 +123,8 @@ namespace detail return abs(fastAtan(y / x)) * sgn; } - template class vecType> - GLM_FUNC_QUALIFIER vecType fastAtan(vecType const & y, vecType const & x) + template + GLM_FUNC_QUALIFIER vec fastAtan(vec const& y, vec const& x) { return detail::functor2::call(fastAtan, y, x); } @@ -135,8 +135,8 @@ namespace detail 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) + template + GLM_FUNC_QUALIFIER vec fastAtan(vec const& x) { return detail::functor1::call(fastAtan, x); } diff --git a/glm/gtx/float_notmalize.inl b/glm/gtx/float_notmalize.inl index 665e2fbd..69f2c483 100644 --- a/glm/gtx/float_notmalize.inl +++ b/glm/gtx/float_notmalize.inl @@ -5,10 +5,10 @@ namespace glm { - template class vecType> - GLM_FUNC_QUALIFIER vecType floatNormalize(vecType const & v) + template + GLM_FUNC_QUALIFIER vec floatNormalize(vec const & v) { - return vecType(v) / static_cast(std::numeric_limits::max()); + return vec(v) / static_cast(std::numeric_limits::max()); } }//namespace glm diff --git a/glm/gtx/gradient_paint.hpp b/glm/gtx/gradient_paint.hpp index 50a930dd..eb34d640 100644 --- a/glm/gtx/gradient_paint.hpp +++ b/glm/gtx/gradient_paint.hpp @@ -31,7 +31,7 @@ namespace glm /// Return a color from a radial gradient. /// @see - gtx_gradient_paint - template + template GLM_FUNC_DECL T radialGradient( vec<2, T, P> const & Center, T const & Radius, @@ -40,7 +40,7 @@ namespace glm /// Return a color from a linear gradient. /// @see - gtx_gradient_paint - template + template GLM_FUNC_DECL T linearGradient( vec<2, T, P> const & Point0, vec<2, T, P> const & Point1, diff --git a/glm/gtx/gradient_paint.inl b/glm/gtx/gradient_paint.inl index ef8b7e4e..5a10fb7a 100644 --- a/glm/gtx/gradient_paint.inl +++ b/glm/gtx/gradient_paint.inl @@ -3,7 +3,7 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER T radialGradient ( vec<2, T, P> const & Center, @@ -23,7 +23,7 @@ namespace glm return Numerator / Denominator; } - template + template GLM_FUNC_QUALIFIER T linearGradient ( vec<2, T, P> const & Point0, diff --git a/glm/gtx/handed_coordinate_space.hpp b/glm/gtx/handed_coordinate_space.hpp index 61491940..d82738f6 100644 --- a/glm/gtx/handed_coordinate_space.hpp +++ b/glm/gtx/handed_coordinate_space.hpp @@ -30,7 +30,7 @@ namespace glm //! Return if a trihedron right handed or not. //! From GLM_GTX_handed_coordinate_space extension. - template + template GLM_FUNC_DECL bool rightHanded( vec<3, T, P> const & tangent, vec<3, T, P> const & binormal, @@ -38,7 +38,7 @@ namespace glm //! Return if a trihedron left handed or not. //! From GLM_GTX_handed_coordinate_space extension. - template + template GLM_FUNC_DECL bool leftHanded( vec<3, T, P> const & tangent, vec<3, T, P> const & binormal, diff --git a/glm/gtx/handed_coordinate_space.inl b/glm/gtx/handed_coordinate_space.inl index d95fcd08..2d37e94d 100644 --- a/glm/gtx/handed_coordinate_space.inl +++ b/glm/gtx/handed_coordinate_space.inl @@ -3,7 +3,7 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER bool rightHanded ( vec<3, T, P> const & tangent, @@ -14,7 +14,7 @@ namespace glm return dot(cross(normal, tangent), binormal) > T(0); } - template + template GLM_FUNC_QUALIFIER bool leftHanded ( vec<3, T, P> const & tangent, diff --git a/glm/gtx/hash.hpp b/glm/gtx/hash.hpp index d457e99a..83956dd5 100644 --- a/glm/gtx/hash.hpp +++ b/glm/gtx/hash.hpp @@ -44,91 +44,91 @@ namespace std { - template + template struct hash > { GLM_FUNC_DECL size_t operator()(glm::vec<1, T, P> const & v) const; }; - template + template struct hash > { GLM_FUNC_DECL size_t operator()(glm::vec<2, T, P> const & v) const; }; - template + template struct hash > { GLM_FUNC_DECL size_t operator()(glm::vec<3, T, P> const & v) const; }; - template + template struct hash > { GLM_FUNC_DECL size_t operator()(glm::vec<4, T, P> const & v) const; }; - template + template struct hash> { GLM_FUNC_DECL size_t operator()(glm::tquat const & q) const; }; - template + template struct hash > { GLM_FUNC_DECL size_t operator()(glm::tdualquat const & q) const; }; - template + template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<2, 2, T,P> const & m) const; }; - template + template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<2, 3, T,P> const & m) const; }; - template + template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<2, 4, T,P> const & m) const; }; - template + template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<3, 2, T,P> const & m) const; }; - template + template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<3, 3, T,P> const & m) const; }; - template + template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<3, 4, T,P> const & m) const; }; - template + template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<4, 2, T,P> const & m) const; }; - template + template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<4, 3, T,P> const & m) const; }; - template + template struct hash > { GLM_FUNC_DECL size_t operator()(glm::mat<4, 4, T,P> const & m) const; diff --git a/glm/gtx/hash.inl b/glm/gtx/hash.inl index 1e1e72ff..97ec740e 100644 --- a/glm/gtx/hash.inl +++ b/glm/gtx/hash.inl @@ -22,14 +22,14 @@ namespace detail namespace std { - template + template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::vec<1, T, P> const & v) const { hash hasher; return hasher(v.x); } - template + template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::vec<2, T, P> const & v) const { size_t seed = 0; @@ -39,7 +39,7 @@ namespace std return seed; } - template + template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::vec<3, T, P> const & v) const { size_t seed = 0; @@ -50,7 +50,7 @@ namespace std return seed; } - template + template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::vec<4, T, P> const & v) const { size_t seed = 0; @@ -62,7 +62,7 @@ namespace std return seed; } - template + template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::tquat const & q) const { size_t seed = 0; @@ -74,7 +74,7 @@ namespace std return seed; } - template + template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::tdualquat const & q) const { size_t seed = 0; @@ -84,7 +84,7 @@ namespace std return seed; } - template + template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<2, 2, T, P> const& m) const { size_t seed = 0; @@ -94,7 +94,7 @@ namespace std return seed; } - template + template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<2, 3, T, P> const& m) const { size_t seed = 0; @@ -104,7 +104,7 @@ namespace std return seed; } - template + template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<2, 4, T, P> const& m) const { size_t seed = 0; @@ -114,7 +114,7 @@ namespace std return seed; } - template + template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<3, 2, T, P> const& m) const { size_t seed = 0; @@ -125,7 +125,7 @@ namespace std return seed; } - template + template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<3, 3, T, P> const& m) const { size_t seed = 0; @@ -136,7 +136,7 @@ namespace std return seed; } - template + template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<3, 4, T, P> const& m) const { size_t seed = 0; @@ -147,7 +147,7 @@ namespace std return seed; } - template + template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<4, 2, T,P> const & m) const { size_t seed = 0; @@ -159,7 +159,7 @@ namespace std return seed; } - template + template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<4, 3, T,P> const & m) const { size_t seed = 0; @@ -171,7 +171,7 @@ namespace std return seed; } - template + template GLM_FUNC_QUALIFIER size_t hash>::operator()(glm::mat<4, 4, T, P> const& m) const { size_t seed = 0; diff --git a/glm/gtx/integer.inl b/glm/gtx/integer.inl index ce386f8b..633f46e7 100644 --- a/glm/gtx/integer.inl +++ b/glm/gtx/integer.inl @@ -80,7 +80,7 @@ namespace detail return Result; } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> factorial( vec<2, T, P> const & x) { @@ -89,7 +89,7 @@ namespace detail factorial(x.y)); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> factorial( vec<3, T, P> const & x) { @@ -99,7 +99,7 @@ namespace detail factorial(x.z)); } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> factorial( vec<4, T, P> const & x) { diff --git a/glm/gtx/intersect.hpp b/glm/gtx/intersect.hpp index a6a78633..9da5d3d3 100644 --- a/glm/gtx/intersect.hpp +++ b/glm/gtx/intersect.hpp @@ -46,7 +46,7 @@ namespace glm //! Compute the intersection of a ray and a triangle. /// Based om Tomas Möller implementation http://fileadmin.cs.lth.se/cs/Personal/Tomas_Akenine-Moller/raytri/ //! From GLM_GTX_intersect extension. - template + template GLM_FUNC_DECL bool intersectRayTriangle( vec<3, T, P> const& orig, vec<3, T, P> const& dir, vec<3, T, P> const& v0, vec<3, T, P> const& v1, vec<3, T, P> const& v2, diff --git a/glm/gtx/intersect.inl b/glm/gtx/intersect.inl index b97b073e..e50da76f 100644 --- a/glm/gtx/intersect.inl +++ b/glm/gtx/intersect.inl @@ -23,7 +23,7 @@ namespace glm return false; } - template + template GLM_FUNC_QUALIFIER bool intersectRayTriangle ( vec<3, T, P> const& orig, vec<3, T, P> const& dir, diff --git a/glm/gtx/io.hpp b/glm/gtx/io.hpp index c1a2d274..1a344399 100644 --- a/glm/gtx/io.hpp +++ b/glm/gtx/io.hpp @@ -11,7 +11,7 @@ /// /// @brief std::[w]ostream support for glm types /// -/// std::[w]ostream support for glm types + precision/width/etc. manipulators +/// std::[w]ostream support for glm types + qualifier/width/etc. manipulators /// based on howard hinnant's std::chrono io proposal /// [http://home.roadrunner.com/~hinnant/bloomington/chrono_io.html] /// @@ -162,36 +162,36 @@ namespace glm std::basic_ostream& operator<<(std::basic_ostream&, order const&); }//namespace io - template + template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, tquat const&); - template + template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, vec<1, T,P> const&); - template + template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, vec<2, T,P> const&); - template + template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, vec<3, T,P> const&); - template + template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, vec<4, T,P> const&); - template + template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<2, 2, T,P> const&); - template + template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<2, 3, T,P> const&); - template + template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<2, 4, T,P> const&); - template + template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<3, 2, T,P> const&); - template + template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<3, 3, T,P> const&); - template + template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<3, 4, T,P> const&); - template + template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<4, 2, T,P> const&); - template + template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<4, 3, T,P> const&); - template + template GLM_FUNC_DECL std::basic_ostream& operator<<(std::basic_ostream&, mat<4, 4, T,P> const&); - template + template GLM_FUNC_DECL std::basic_ostream & operator<<(std::basic_ostream &, std::pair const, mat<4, 4, T,P> const> const &); diff --git a/glm/gtx/io.inl b/glm/gtx/io.inl index e4f72570..c1df2d88 100644 --- a/glm/gtx/io.inl +++ b/glm/gtx/io.inl @@ -195,31 +195,31 @@ namespace detail } }//namespace detail - template + template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, tquat const& a) { return detail::print_vector_on(os, a); } - template + template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, vec<1, T,P> const& a) { return detail::print_vector_on(os, a); } - template + template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, vec<2, T,P> const& a) { return detail::print_vector_on(os, a); } - template + template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, vec<3, T,P> const& a) { return detail::print_vector_on(os, a); } - template + template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, vec<4, T,P> const& a) { return detail::print_vector_on(os, a); @@ -227,7 +227,7 @@ namespace detail namespace detail { - template class M, length_t C, length_t R, typename T, precision P> + template class M, length_t C, length_t R, typename T, qualifier 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); @@ -313,55 +313,55 @@ namespace detail } }//namespace detail - template + template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, mat<2, 2, T, P> const& a) { return detail::print_matrix_on(os, a); } - template + template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, mat<2, 3, T, P> const& a) { return detail::print_matrix_on(os, a); } - template + template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, mat<2, 4, T, P> const& a) { return detail::print_matrix_on(os, a); } - template + template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, mat<3, 2, T,P> const& a) { return detail::print_matrix_on(os, a); } - template + template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<(std::basic_ostream& os, mat<3, 3, T,P> const& a) { return detail::print_matrix_on(os, a); } - template + template GLM_FUNC_QUALIFIER std::basic_ostream & operator<<(std::basic_ostream& os, mat<3, 4, T,P> const& a) { return detail::print_matrix_on(os, a); } - template + template GLM_FUNC_QUALIFIER std::basic_ostream & operator<<(std::basic_ostream& os, mat<4, 2, T,P> const& a) { return detail::print_matrix_on(os, a); } - template + template GLM_FUNC_QUALIFIER std::basic_ostream & operator<<(std::basic_ostream& os, mat<4, 3, T,P> const& a) { return detail::print_matrix_on(os, a); } - template + template GLM_FUNC_QUALIFIER std::basic_ostream & operator<<(std::basic_ostream& os, mat<4, 4, T,P> const& a) { return detail::print_matrix_on(os, a); @@ -369,7 +369,7 @@ namespace detail namespace detail { - template class M, length_t C, length_t R, typename T, precision P> + template class M, length_t C, length_t R, typename T, qualifier 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); @@ -430,7 +430,7 @@ namespace detail } }//namespace detail - template + template GLM_FUNC_QUALIFIER std::basic_ostream& operator<<( std::basic_ostream & os, std::pair const, diff --git a/glm/gtx/log_base.hpp b/glm/gtx/log_base.hpp index 577c7914..9e7550ae 100644 --- a/glm/gtx/log_base.hpp +++ b/glm/gtx/log_base.hpp @@ -37,10 +37,10 @@ namespace glm /// Logarithm for any base. /// From GLM_GTX_log_base. - template class vecType> - GLM_FUNC_DECL vecType sign( - vecType const& x, - vecType const& base); + template + GLM_FUNC_DECL vec sign( + vec const& x, + vec const& base); /// @} }//namespace glm diff --git a/glm/gtx/log_base.inl b/glm/gtx/log_base.inl index fc31e781..a4b926e4 100644 --- a/glm/gtx/log_base.inl +++ b/glm/gtx/log_base.inl @@ -4,14 +4,14 @@ namespace glm { template - GLM_FUNC_QUALIFIER genType log(genType const & x, genType const & base) + GLM_FUNC_QUALIFIER genType log(genType const& x, genType const& base) { assert(!detail::compute_equal::call(x, static_cast(0))); return glm::log(x) / glm::log(base); } - template class vecType> - GLM_FUNC_QUALIFIER vecType log(vecType const & x, vecType const & base) + template + GLM_FUNC_QUALIFIER vec log(vec const& x, vec const& base) { return glm::log(x) / glm::log(base); } diff --git a/glm/gtx/matrix_cross_product.hpp b/glm/gtx/matrix_cross_product.hpp index 0b1bb48e..10704893 100644 --- a/glm/gtx/matrix_cross_product.hpp +++ b/glm/gtx/matrix_cross_product.hpp @@ -31,13 +31,13 @@ namespace glm //! Build a cross product matrix. //! From GLM_GTX_matrix_cross_product extension. - template + template GLM_FUNC_DECL mat<3, 3, T, P> matrixCross3( vec<3, T, P> const & x); //! Build a cross product matrix. //! From GLM_GTX_matrix_cross_product extension. - template + template GLM_FUNC_DECL mat<4, 4, T, P> matrixCross4( vec<3, T, P> const & x); diff --git a/glm/gtx/matrix_cross_product.inl b/glm/gtx/matrix_cross_product.inl index e1b2fe90..2e349cc3 100644 --- a/glm/gtx/matrix_cross_product.inl +++ b/glm/gtx/matrix_cross_product.inl @@ -3,7 +3,7 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> matrixCross3 ( vec<3, T, P> const & x @@ -19,7 +19,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> matrixCross4 ( vec<3, T, P> const & x diff --git a/glm/gtx/matrix_decompose.hpp b/glm/gtx/matrix_decompose.hpp index 5a9225ce..94fc24d7 100644 --- a/glm/gtx/matrix_decompose.hpp +++ b/glm/gtx/matrix_decompose.hpp @@ -35,7 +35,7 @@ namespace glm /// Decomposes a model matrix to translations, rotation and scale components /// @see gtx_matrix_decompose - template + template GLM_FUNC_DECL bool decompose( mat<4, 4, T, P> const& modelMatrix, vec<3, T, P> & scale, tquat & orientation, vec<3, T, P> & translation, vec<3, T, P> & skew, vec<4, T, P> & perspective); diff --git a/glm/gtx/matrix_decompose.inl b/glm/gtx/matrix_decompose.inl index 68b62a48..03d9a14a 100644 --- a/glm/gtx/matrix_decompose.inl +++ b/glm/gtx/matrix_decompose.inl @@ -9,7 +9,7 @@ namespace detail { /// Make a linear combination of two vectors and return the result. // result = (a * ascl) + (b * bscl) - template + template GLM_FUNC_QUALIFIER vec<3, T, P> combine( vec<3, T, P> const & a, vec<3, T, P> const & b, @@ -18,7 +18,7 @@ namespace detail return (a * ascl) + (b * bscl); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> scale(vec<3, T, P> const& v, T desiredLength) { return v * desiredLength / length(v); @@ -29,7 +29,7 @@ namespace detail // http://www.opensource.apple.com/source/WebCore/WebCore-514/platform/graphics/transforms/TransformationMatrix.cpp // Decomposes the mode matrix to translations,rotation scale components - template + template GLM_FUNC_QUALIFIER bool decompose(mat<4, 4, T, P> const & ModelMatrix, vec<3, T, P> & Scale, tquat & Orientation, vec<3, T, P> & Translation, vec<3, T, P> & Skew, vec<4, T, P> & Perspective) { mat<4, 4, T, P> LocalMatrix(ModelMatrix); diff --git a/glm/gtx/matrix_factorisation.hpp b/glm/gtx/matrix_factorisation.hpp index fafbff09..096cdebc 100644 --- a/glm/gtx/matrix_factorisation.hpp +++ b/glm/gtx/matrix_factorisation.hpp @@ -36,19 +36,19 @@ namespace glm /// Flips the matrix rows up and down. /// From GLM_GTX_matrix_factorisation extension. - template class matType> + template class matType> GLM_FUNC_DECL matType flipud(matType const& in); /// Flips the matrix columns right and left. /// From GLM_GTX_matrix_factorisation extension. - template class matType> + template class matType> GLM_FUNC_DECL matType fliplr(matType const& in); /// Performs QR factorisation of a matrix. /// Returns 2 matrices, q and r, such that the columns of q are orthonormal and span the same subspace than those of the input matrix, r is an upper triangular matrix, and q*r=in. /// Given an n-by-m input matrix, q has dimensions min(n,m)-by-m, and r has dimensions n-by-min(n,m). /// From GLM_GTX_matrix_factorisation extension. - template class matType> + template class matType> GLM_FUNC_DECL void qr_decompose(matType const& in, matType<(C < R ? C : R), R, T, P>& q, matType& r); /// Performs RQ factorisation of a matrix. @@ -56,7 +56,7 @@ namespace glm /// Note that in the context of RQ factorisation, the diagonal is seen as starting in the lower-right corner of the matrix, instead of the usual upper-left. /// Given an n-by-m input matrix, r has dimensions min(n,m)-by-m, and q has dimensions n-by-min(n,m). /// From GLM_GTX_matrix_factorisation extension. - template class matType> + template class matType> GLM_FUNC_DECL void rq_decompose(matType const& in, matType<(C < R ? C : R), R, T, P>& r, matType& q); /// @} diff --git a/glm/gtx/matrix_factorisation.inl b/glm/gtx/matrix_factorisation.inl index 7f2418c0..fe37daef 100644 --- a/glm/gtx/matrix_factorisation.inl +++ b/glm/gtx/matrix_factorisation.inl @@ -3,7 +3,7 @@ namespace glm { - template class matType> + template class matType> GLM_FUNC_QUALIFIER matType flipud(matType const& in) { matType tin = transpose(in); @@ -13,7 +13,7 @@ namespace glm return out; } - template class matType> + template class matType> GLM_FUNC_QUALIFIER matType fliplr(matType const& in) { matType out; @@ -25,7 +25,7 @@ namespace glm return out; } - template class matType> + template class matType> GLM_FUNC_QUALIFIER void qr_decompose(matType const& in, matType<(C < R ? C : R), R, T, P>& q, matType& r) { // Uses modified Gram-Schmidt method @@ -60,7 +60,7 @@ namespace glm } } - template class matType> + template class matType> GLM_FUNC_QUALIFIER void rq_decompose(matType const& in, matType<(C < R ? C : R), R, T, P>& r, matType& q) { // From https://en.wikipedia.org/wiki/QR_decomposition: diff --git a/glm/gtx/matrix_interpolation.hpp b/glm/gtx/matrix_interpolation.hpp index 4e7f49dd..da36fd23 100644 --- a/glm/gtx/matrix_interpolation.hpp +++ b/glm/gtx/matrix_interpolation.hpp @@ -31,7 +31,7 @@ namespace glm /// Get the axis and angle of the rotation from a matrix. /// From GLM_GTX_matrix_interpolation extension. - template + template GLM_FUNC_DECL void axisAngle( mat<4, 4, T, P> const& mat, vec<3, T, P> & axis, @@ -39,21 +39,21 @@ namespace glm /// Build a matrix from axis and angle. /// From GLM_GTX_matrix_interpolation extension. - template + template GLM_FUNC_DECL mat<4, 4, T, P> axisAngleMatrix( vec<3, T, P> const & axis, T const angle); /// Extracts the rotation part of a matrix. /// From GLM_GTX_matrix_interpolation extension. - template + template GLM_FUNC_DECL mat<4, 4, T, P> extractMatrixRotation( mat<4, 4, T, P> 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 + template GLM_FUNC_DECL mat<4, 4, T, P> interpolate( mat<4, 4, T, P> const& m1, mat<4, 4, T, P> const& m2, diff --git a/glm/gtx/matrix_interpolation.inl b/glm/gtx/matrix_interpolation.inl index 3d981d7f..0cc7d462 100644 --- a/glm/gtx/matrix_interpolation.inl +++ b/glm/gtx/matrix_interpolation.inl @@ -5,7 +5,7 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER void axisAngle(mat<4, 4, T, P> const& mat, vec<3, T, P> & axis, T & angle) { T epsilon = static_cast(0.01); @@ -88,7 +88,7 @@ namespace glm axis.z = (mat[0][1] - mat[1][0]) / s; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> axisAngleMatrix(vec<3, T, P> const & axis, T const angle) { T c = cos(angle); @@ -103,7 +103,7 @@ namespace glm static_cast(0.0), static_cast(0.0), static_cast(0.0), static_cast(1.0)); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> extractMatrixRotation(mat<4, 4, T, P> const& m) { return mat<4, 4, T, P>( @@ -113,7 +113,7 @@ namespace glm static_cast(0.0), static_cast(0.0), static_cast(0.0), static_cast(1.0)); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> interpolate(mat<4, 4, T, P> const& m1, mat<4, 4, T, P> const& m2, T const delta) { mat<4, 4, T, P> m1rot = extractMatrixRotation(m1); diff --git a/glm/gtx/matrix_major_storage.hpp b/glm/gtx/matrix_major_storage.hpp index 90f57967..1fcf78fd 100644 --- a/glm/gtx/matrix_major_storage.hpp +++ b/glm/gtx/matrix_major_storage.hpp @@ -31,20 +31,20 @@ namespace glm //! Build a row major matrix from row vectors. //! From GLM_GTX_matrix_major_storage extension. - template + template GLM_FUNC_DECL mat<2, 2, T, P> rowMajor2( vec<2, T, P> const & v1, vec<2, T, P> const & v2); //! Build a row major matrix from other matrix. //! From GLM_GTX_matrix_major_storage extension. - template + template GLM_FUNC_DECL mat<2, 2, T, P> rowMajor2( mat<2, 2, T, P> const& m); //! Build a row major matrix from row vectors. //! From GLM_GTX_matrix_major_storage extension. - template + template GLM_FUNC_DECL mat<3, 3, T, P> rowMajor3( vec<3, T, P> const & v1, vec<3, T, P> const & v2, @@ -52,13 +52,13 @@ namespace glm //! Build a row major matrix from other matrix. //! From GLM_GTX_matrix_major_storage extension. - template + template GLM_FUNC_DECL mat<3, 3, T, P> rowMajor3( mat<3, 3, T, P> const& m); //! Build a row major matrix from row vectors. //! From GLM_GTX_matrix_major_storage extension. - template + template GLM_FUNC_DECL mat<4, 4, T, P> rowMajor4( vec<4, T, P> const & v1, vec<4, T, P> const & v2, @@ -67,26 +67,26 @@ namespace glm //! Build a row major matrix from other matrix. //! From GLM_GTX_matrix_major_storage extension. - template + template GLM_FUNC_DECL mat<4, 4, T, P> rowMajor4( mat<4, 4, T, P> const& m); //! Build a column major matrix from column vectors. //! From GLM_GTX_matrix_major_storage extension. - template + template GLM_FUNC_DECL mat<2, 2, T, P> colMajor2( vec<2, T, P> const & v1, vec<2, T, P> const & v2); //! Build a column major matrix from other matrix. //! From GLM_GTX_matrix_major_storage extension. - template + template GLM_FUNC_DECL mat<2, 2, T, P> colMajor2( mat<2, 2, T, P> const& m); //! Build a column major matrix from column vectors. //! From GLM_GTX_matrix_major_storage extension. - template + template GLM_FUNC_DECL mat<3, 3, T, P> colMajor3( vec<3, T, P> const & v1, vec<3, T, P> const & v2, @@ -94,13 +94,13 @@ namespace glm //! Build a column major matrix from other matrix. //! From GLM_GTX_matrix_major_storage extension. - template + template GLM_FUNC_DECL mat<3, 3, T, P> colMajor3( mat<3, 3, T, P> const& m); //! Build a column major matrix from column vectors. //! From GLM_GTX_matrix_major_storage extension. - template + template GLM_FUNC_DECL mat<4, 4, T, P> colMajor4( vec<4, T, P> const & v1, vec<4, T, P> const & v2, @@ -109,7 +109,7 @@ namespace glm //! Build a column major matrix from other matrix. //! From GLM_GTX_matrix_major_storage extension. - template + template GLM_FUNC_DECL mat<4, 4, T, P> colMajor4( mat<4, 4, T, P> const& m); diff --git a/glm/gtx/matrix_major_storage.inl b/glm/gtx/matrix_major_storage.inl index 6a21216f..238c4dbe 100644 --- a/glm/gtx/matrix_major_storage.inl +++ b/glm/gtx/matrix_major_storage.inl @@ -3,7 +3,7 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> rowMajor2 ( vec<2, T, P> const & v1, @@ -18,7 +18,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> rowMajor2( const mat<2, 2, T, P>& m) { @@ -30,7 +30,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> rowMajor3( const vec<3, T, P>& v1, const vec<3, T, P>& v2, @@ -49,7 +49,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> rowMajor3( const mat<3, 3, T, P>& m) { @@ -66,7 +66,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> rowMajor4( const vec<4, T, P>& v1, const vec<4, T, P>& v2, @@ -93,7 +93,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> rowMajor4( const mat<4, 4, T, P>& m) { @@ -117,7 +117,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> colMajor2( const vec<2, T, P>& v1, const vec<2, T, P>& v2) @@ -125,14 +125,14 @@ namespace glm return mat<2, 2, T, P>(v1, v2); } - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> colMajor2( const mat<2, 2, T, P>& m) { return mat<2, 2, T, P>(m); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> colMajor3( const vec<3, T, P>& v1, const vec<3, T, P>& v2, @@ -141,14 +141,14 @@ namespace glm return mat<3, 3, T, P>(v1, v2, v3); } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> colMajor3( const mat<3, 3, T, P>& m) { return mat<3, 3, T, P>(m); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> colMajor4( const vec<4, T, P>& v1, const vec<4, T, P>& v2, @@ -158,7 +158,7 @@ namespace glm return mat<4, 4, T, P>(v1, v2, v3, v4); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> colMajor4( const mat<4, 4, T, P>& m) { diff --git a/glm/gtx/matrix_operation.hpp b/glm/gtx/matrix_operation.hpp index 853e27cf..ad8a99a6 100644 --- a/glm/gtx/matrix_operation.hpp +++ b/glm/gtx/matrix_operation.hpp @@ -30,55 +30,55 @@ namespace glm //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. - template + template GLM_FUNC_DECL mat<2, 2, T, P> diagonal2x2( vec<2, T, P> const & v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. - template + template GLM_FUNC_DECL mat<2, 3, T, P> diagonal2x3( vec<2, T, P> const & v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. - template + template GLM_FUNC_DECL mat<2, 4, T, P> diagonal2x4( vec<2, T, P> const & v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. - template + template GLM_FUNC_DECL mat<3, 2, T, P> diagonal3x2( vec<2, T, P> const & v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. - template + template GLM_FUNC_DECL mat<3, 3, T, P> diagonal3x3( vec<3, T, P> const & v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. - template + template GLM_FUNC_DECL mat<3, 4, T, P> diagonal3x4( vec<3, T, P> const & v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. - template + template GLM_FUNC_DECL mat<4, 2, T, P> diagonal4x2( vec<2, T, P> const & v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. - template + template GLM_FUNC_DECL mat<4, 3, T, P> diagonal4x3( vec<3, T, P> const & v); //! Build a diagonal matrix. //! From GLM_GTX_matrix_operation extension. - template + template GLM_FUNC_DECL mat<4, 4, T, P> diagonal4x4( vec<4, T, P> const & v); diff --git a/glm/gtx/matrix_operation.inl b/glm/gtx/matrix_operation.inl index 9816d52e..ad17898e 100644 --- a/glm/gtx/matrix_operation.inl +++ b/glm/gtx/matrix_operation.inl @@ -3,7 +3,7 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER mat<2, 2, T, P> diagonal2x2 ( vec<2, T, P> const & v @@ -15,7 +15,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<2, 3, T, P> diagonal2x3 ( vec<2, T, P> const & v @@ -27,7 +27,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<2, 4, T, P> diagonal2x4 ( vec<2, T, P> const & v @@ -39,7 +39,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<3, 2, T, P> diagonal3x2 ( vec<2, T, P> const & v @@ -51,7 +51,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> diagonal3x3 ( vec<3, T, P> const & v @@ -64,7 +64,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<3, 4, T, P> diagonal3x4 ( vec<3, T, P> const & v @@ -77,7 +77,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> diagonal4x4 ( vec<4, T, P> const & v @@ -91,7 +91,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<4, 3, T, P> diagonal4x3 ( vec<3, T, P> const & v @@ -104,7 +104,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<4, 2, T, P> diagonal4x2 ( vec<2, T, P> const & v diff --git a/glm/gtx/matrix_query.hpp b/glm/gtx/matrix_query.hpp index f686e6d9..d81f112f 100644 --- a/glm/gtx/matrix_query.hpp +++ b/glm/gtx/matrix_query.hpp @@ -33,42 +33,42 @@ namespace glm /// Return whether a matrix a null matrix. /// From GLM_GTX_matrix_query extension. - template + template GLM_FUNC_DECL bool isNull(mat<2, 2, T, P> const & m, T const & epsilon); /// Return whether a matrix a null matrix. /// From GLM_GTX_matrix_query extension. - template + template GLM_FUNC_DECL bool isNull(mat<3, 3, T, P> const & m, T const & epsilon); /// Return whether a matrix is a null matrix. /// From GLM_GTX_matrix_query extension. - template + template GLM_FUNC_DECL bool isNull(mat<4, 4, T, P> const & m, T const & epsilon); /// Return whether a matrix is an identity matrix. /// From GLM_GTX_matrix_query extension. - template class matType> + 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 + template GLM_FUNC_DECL bool isNormalized(mat<2, 2, T, P> const & m, T const & epsilon); /// Return whether a matrix is a normalized matrix. /// From GLM_GTX_matrix_query extension. - template + template GLM_FUNC_DECL bool isNormalized(mat<3, 3, T, P> const & m, T const & epsilon); /// Return whether a matrix is a normalized matrix. /// From GLM_GTX_matrix_query extension. - template + template GLM_FUNC_DECL bool isNormalized(mat<4, 4, T, P> const & m, T const & epsilon); /// Return whether a matrix is an orthonormalized matrix. /// From GLM_GTX_matrix_query extension. - template class matType> + template class matType> GLM_FUNC_DECL bool isOrthogonal(matType const & m, T const & epsilon); /// @} diff --git a/glm/gtx/matrix_query.inl b/glm/gtx/matrix_query.inl index 89cc8a3f..0eb71e8f 100644 --- a/glm/gtx/matrix_query.inl +++ b/glm/gtx/matrix_query.inl @@ -3,8 +3,8 @@ namespace glm { - template - GLM_FUNC_QUALIFIER bool isNull(mat<2, 2, T, P> const & m, T const & epsilon) + template + GLM_FUNC_QUALIFIER bool isNull(mat<2, 2, T, P> const& m, T const& epsilon) { bool result = true; for(length_t i = 0; result && i < m.length() ; ++i) @@ -12,8 +12,8 @@ namespace glm return result; } - template - GLM_FUNC_QUALIFIER bool isNull(mat<3, 3, T, P> const & m, T const & epsilon) + template + GLM_FUNC_QUALIFIER bool isNull(mat<3, 3, T, P> const& m, T const& epsilon) { bool result = true; for(length_t i = 0; result && i < m.length() ; ++i) @@ -21,8 +21,8 @@ namespace glm return result; } - template - GLM_FUNC_QUALIFIER bool isNull(mat<4, 4, T, P> const & m, T const & epsilon) + template + GLM_FUNC_QUALIFIER bool isNull(mat<4, 4, T, P> const& m, T const& epsilon) { bool result = true; for(length_t i = 0; result && i < m.length() ; ++i) @@ -30,8 +30,8 @@ namespace glm return result; } - template class matType> - GLM_FUNC_QUALIFIER bool isIdentity(matType const & m, T const & epsilon) + template + GLM_FUNC_QUALIFIER bool isIdentity(mat const& m, T const& epsilon) { bool result = true; for(length_t i = 0; result && i < m[0].length() ; ++i) @@ -46,8 +46,8 @@ namespace glm return result; } - template - GLM_FUNC_QUALIFIER bool isNormalized(mat<2, 2, T, P> const & m, T const & epsilon) + template + GLM_FUNC_QUALIFIER bool isNormalized(mat<2, 2, T, P> const& m, T const& epsilon) { bool result(true); for(length_t i = 0; result && i < m.length(); ++i) @@ -62,8 +62,8 @@ namespace glm return result; } - template - GLM_FUNC_QUALIFIER bool isNormalized(mat<3, 3, T, P> const & m, T const & epsilon) + template + GLM_FUNC_QUALIFIER bool isNormalized(mat<3, 3, T, P> const& m, T const& epsilon) { bool result(true); for(length_t i = 0; result && i < m.length(); ++i) @@ -78,8 +78,8 @@ namespace glm return result; } - template - GLM_FUNC_QUALIFIER bool isNormalized(mat<4, 4, T, P> const & m, T const & epsilon) + template + GLM_FUNC_QUALIFIER bool isNormalized(mat<4, 4, T, P> const& m, T const& epsilon) { bool result(true); for(length_t i = 0; result && i < m.length(); ++i) @@ -94,17 +94,17 @@ namespace glm return result; } - template class matType> - GLM_FUNC_QUALIFIER bool isOrthogonal(matType const & m, T const & epsilon) + template + GLM_FUNC_QUALIFIER bool isOrthogonal(mat const& m, T const& epsilon) { - bool result(true); + 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); + mat 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); diff --git a/glm/gtx/matrix_transform_2d.hpp b/glm/gtx/matrix_transform_2d.hpp index b7a23a35..443db9f6 100644 --- a/glm/gtx/matrix_transform_2d.hpp +++ b/glm/gtx/matrix_transform_2d.hpp @@ -34,7 +34,7 @@ namespace glm /// /// @param m Input matrix multiplied by this translation matrix. /// @param v Coordinates of a translation vector. - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> translate( mat<3, 3, T, P> const& m, vec<2, T, P> const & v); @@ -43,7 +43,7 @@ namespace glm /// /// @param m Input matrix multiplied by this translation matrix. /// @param angle Rotation angle expressed in radians. - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> rotate( mat<3, 3, T, P> const& m, T angle); @@ -52,7 +52,7 @@ namespace glm /// /// @param m Input matrix multiplied by this translation matrix. /// @param v Coordinates of a scale vector. - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> scale( mat<3, 3, T, P> const& m, vec<2, T, P> const & v); @@ -61,7 +61,7 @@ namespace glm /// /// @param m Input matrix multiplied by this translation matrix. /// @param y Shear factor. - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> shearX( mat<3, 3, T, P> const& m, T y); @@ -70,7 +70,7 @@ namespace glm /// /// @param m Input matrix multiplied by this translation matrix. /// @param x Shear factor. - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> shearY( mat<3, 3, T, P> const& m, T x); diff --git a/glm/gtx/matrix_transform_2d.inl b/glm/gtx/matrix_transform_2d.inl index 4b72896b..95262aa9 100644 --- a/glm/gtx/matrix_transform_2d.inl +++ b/glm/gtx/matrix_transform_2d.inl @@ -7,7 +7,7 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> translate( mat<3, 3, T, P> const& m, vec<2, T, P> const & v) @@ -18,7 +18,7 @@ namespace glm } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> rotate( mat<3, 3, T, P> const& m, T angle) @@ -34,7 +34,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> scale( mat<3, 3, T, P> const& m, vec<2, T, P> const & v) @@ -46,7 +46,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> shearX( mat<3, 3, T, P> const& m, T y) @@ -56,7 +56,7 @@ namespace glm return m * Result; } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> shearY( mat<3, 3, T, P> const& m, T x) diff --git a/glm/gtx/mixed_product.hpp b/glm/gtx/mixed_product.hpp index 4d008939..efb57d38 100644 --- a/glm/gtx/mixed_product.hpp +++ b/glm/gtx/mixed_product.hpp @@ -29,7 +29,7 @@ namespace glm /// @{ /// @brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension) - template + template GLM_FUNC_DECL T mixedProduct( vec<3, T, P> const & v1, vec<3, T, P> const & v2, diff --git a/glm/gtx/mixed_product.inl b/glm/gtx/mixed_product.inl index 9fe088de..8f0e22f3 100644 --- a/glm/gtx/mixed_product.inl +++ b/glm/gtx/mixed_product.inl @@ -3,7 +3,7 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER T mixedProduct ( vec<3, T, P> const & v1, diff --git a/glm/gtx/norm.hpp b/glm/gtx/norm.hpp index 729e885a..daddfe41 100644 --- a/glm/gtx/norm.hpp +++ b/glm/gtx/norm.hpp @@ -32,57 +32,43 @@ namespace glm /// Returns the squared length of x. /// From GLM_GTX_norm extension. - template class vecType> - GLM_FUNC_DECL T length2( - vecType const& x); + template + GLM_FUNC_DECL T length2(vec 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); + template + GLM_FUNC_DECL T distance2(vec const& p0, vec const& p1); //! Returns the L1 norm between x and y. //! From GLM_GTX_norm extension. - template - GLM_FUNC_DECL T l1Norm( - vec<3, T, P> const & x, - vec<3, T, P> const & y); - + template + GLM_FUNC_DECL T l1Norm(vec<3, T, P> const& x, vec<3, T, P> const& y); + //! Returns the L1 norm of v. //! From GLM_GTX_norm extension. - template - GLM_FUNC_DECL T l1Norm( - vec<3, T, P> const & v); - + template + GLM_FUNC_DECL T l1Norm(vec<3, T, P> const& v); + //! Returns the L2 norm between x and y. //! From GLM_GTX_norm extension. - template - GLM_FUNC_DECL T l2Norm( - vec<3, T, P> const & x, - vec<3, T, P> const & y); + template + GLM_FUNC_DECL T l2Norm(vec<3, T, P> const& x, vec<3, T, P> const& y); //! Returns the L2 norm of v. //! From GLM_GTX_norm extension. - template - GLM_FUNC_DECL T l2Norm( - vec<3, T, P> const & x); + template + GLM_FUNC_DECL T l2Norm(vec<3, T, P> const& x); //! Returns the L norm between x and y. //! From GLM_GTX_norm extension. - template - GLM_FUNC_DECL T lxNorm( - vec<3, T, P> const & x, - vec<3, T, P> const & y, - unsigned int Depth); + template + GLM_FUNC_DECL T lxNorm(vec<3, T, P> const& x, vec<3, T, P> const& y, unsigned int Depth); //! Returns the L norm of v. //! From GLM_GTX_norm extension. - template - GLM_FUNC_DECL T lxNorm( - vec<3, T, P> const & x, - unsigned int Depth); + template + GLM_FUNC_DECL T lxNorm(vec<3, T, P> const& x, unsigned int Depth); /// @} }//namespace glm diff --git a/glm/gtx/norm.inl b/glm/gtx/norm.inl index 49b6a008..c8699583 100644 --- a/glm/gtx/norm.inl +++ b/glm/gtx/norm.inl @@ -1,15 +1,15 @@ /// @ref gtx_norm /// @file glm/gtx/norm.inl -#include "../detail/precision.hpp" +#include "../detail/qualifier.hpp" namespace glm{ namespace detail { - template class vecType, length_t L, typename T, precision P, bool Aligned> + template struct compute_length2 { - GLM_FUNC_QUALIFIER static T call(vecType const & v) + GLM_FUNC_QUALIFIER static T call(vec const & v) { return dot(v, v); } @@ -23,11 +23,11 @@ namespace detail return x * x; } - template class vecType> - GLM_FUNC_QUALIFIER T length2(vecType const & v) + template + GLM_FUNC_QUALIFIER T length2(vec const & v) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'length2' accepts only floating-point inputs"); - return detail::compute_length2::value>::call(v); + return detail::compute_length2::value>::call(v); } template @@ -37,68 +37,46 @@ namespace detail return length2(p1 - p0); } - template class vecType> - GLM_FUNC_QUALIFIER T distance2(vecType const & p0, vecType const & p1) + template + GLM_FUNC_QUALIFIER T distance2(vec const & p0, vec const & p1) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'distance2' accepts only floating-point inputs"); return length2(p1 - p0); } - template - GLM_FUNC_QUALIFIER T l1Norm - ( - vec<3, T, P> const & a, - vec<3, T, P> const & b - ) + template + GLM_FUNC_QUALIFIER T l1Norm(vec<3, T, P> const & a, vec<3, T, P> const & b) { return abs(b.x - a.x) + abs(b.y - a.y) + abs(b.z - a.z); } - template - GLM_FUNC_QUALIFIER T l1Norm - ( - vec<3, T, P> const & v - ) + template + GLM_FUNC_QUALIFIER T l1Norm(vec<3, T, P> const & v) { return abs(v.x) + abs(v.y) + abs(v.z); } - template - GLM_FUNC_QUALIFIER T l2Norm - ( - vec<3, T, P> const & a, - vec<3, T, P> const & b + template + GLM_FUNC_QUALIFIER T l2Norm(vec<3, T, P> const& a, vec<3, T, P> const& b ) { return length(b - a); } - template - GLM_FUNC_QUALIFIER T l2Norm - ( - vec<3, T, P> const & v - ) + template + GLM_FUNC_QUALIFIER T l2Norm(vec<3, T, P> const & v) { return length(v); } - template - GLM_FUNC_QUALIFIER T lxNorm - ( - vec<3, T, P> const & x, - vec<3, T, P> const & y, - unsigned int Depth - ) + template + GLM_FUNC_QUALIFIER T lxNorm(vec<3, T, P> const & x, vec<3, T, P> const & y, unsigned int Depth) { return pow(pow(y.x - x.x, T(Depth)) + pow(y.y - x.y, T(Depth)) + pow(y.z - x.z, T(Depth)), T(1) / T(Depth)); } - template - GLM_FUNC_QUALIFIER T lxNorm - ( - vec<3, T, P> const & v, - unsigned int Depth - ) + template + GLM_FUNC_QUALIFIER T lxNorm(vec<3, T, P> const& v, unsigned int Depth) { return pow(pow(v.x, T(Depth)) + pow(v.y, T(Depth)) + pow(v.z, T(Depth)), T(1) / T(Depth)); } diff --git a/glm/gtx/normal.hpp b/glm/gtx/normal.hpp index cd99000a..aa9ec56d 100644 --- a/glm/gtx/normal.hpp +++ b/glm/gtx/normal.hpp @@ -31,7 +31,7 @@ namespace glm //! Computes triangle normal from triangle points. //! From GLM_GTX_normal extension. - template + template GLM_FUNC_DECL vec<3, T, P> triangleNormal( vec<3, T, P> const & p1, vec<3, T, P> const & p2, diff --git a/glm/gtx/normal.inl b/glm/gtx/normal.inl index cdb31dca..94844759 100644 --- a/glm/gtx/normal.inl +++ b/glm/gtx/normal.inl @@ -3,7 +3,7 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER vec<3, T, P> triangleNormal ( vec<3, T, P> const & p1, diff --git a/glm/gtx/normalize_dot.hpp b/glm/gtx/normalize_dot.hpp index a4977d90..86802c21 100644 --- a/glm/gtx/normalize_dot.hpp +++ b/glm/gtx/normalize_dot.hpp @@ -33,15 +33,15 @@ namespace glm /// It's faster that dot(normalize(x), normalize(y)). /// /// @see gtx_normalize_dot extension. - template class vecType> - GLM_FUNC_DECL T normalizeDot(vecType const & x, vecType const & y); + template + GLM_FUNC_DECL T normalizeDot(vec const & x, vec const & y); /// Normalize parameters and returns the dot product of x and y. /// Faster that dot(fastNormalize(x), fastNormalize(y)). /// /// @see gtx_normalize_dot extension. - template class vecType> - GLM_FUNC_DECL T fastNormalizeDot(vecType const & x, vecType const & y); + template + GLM_FUNC_DECL T fastNormalizeDot(vec const & x, vec const & y); /// @} }//namespace glm diff --git a/glm/gtx/normalize_dot.inl b/glm/gtx/normalize_dot.inl index 0a90aaf2..bef91f70 100644 --- a/glm/gtx/normalize_dot.inl +++ b/glm/gtx/normalize_dot.inl @@ -3,14 +3,14 @@ namespace glm { - template class vecType> - GLM_FUNC_QUALIFIER T normalizeDot(vecType const & x, vecType const & y) + template + GLM_FUNC_QUALIFIER T normalizeDot(vec const& x, vec const& y) { return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y)); } - template class vecType> - GLM_FUNC_QUALIFIER T fastNormalizeDot(vecType const & x, vecType const & y) + template + GLM_FUNC_QUALIFIER T fastNormalizeDot(vec const& x, vec const& y) { return glm::dot(x, y) * glm::fastInverseSqrt(glm::dot(x, x) * glm::dot(y, y)); } diff --git a/glm/gtx/number_precision.hpp b/glm/gtx/number_precision.hpp index 225977cc..54cb891f 100644 --- a/glm/gtx/number_precision.hpp +++ b/glm/gtx/number_precision.hpp @@ -43,16 +43,16 @@ namespace gtx ////////////////////// // Float vector types - typedef f32 f32vec1; //!< \brief Single-precision floating-point scalar. (from GLM_GTX_number_precision extension) - typedef f64 f64vec1; //!< \brief Single-precision floating-point scalar. (from GLM_GTX_number_precision extension) + typedef f32 f32vec1; //!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) + typedef f64 f64vec1; //!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) ////////////////////// // Float matrix types - typedef f32 f32mat1; //!< \brief Single-precision floating-point scalar. (from GLM_GTX_number_precision extension) - typedef f32 f32mat1x1; //!< \brief Single-precision floating-point scalar. (from GLM_GTX_number_precision extension) - typedef f64 f64mat1; //!< \brief Double-precision floating-point scalar. (from GLM_GTX_number_precision extension) - typedef f64 f64mat1x1; //!< \brief Double-precision floating-point scalar. (from GLM_GTX_number_precision extension) + typedef f32 f32mat1; //!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) + typedef f32 f32mat1x1; //!< \brief Single-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) + typedef f64 f64mat1; //!< \brief Double-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) + typedef f64 f64mat1x1; //!< \brief Double-qualifier floating-point scalar. (from GLM_GTX_number_precision extension) /// @} }//namespace gtx diff --git a/glm/gtx/orthonormalize.hpp b/glm/gtx/orthonormalize.hpp index 562de142..1e1c10d1 100644 --- a/glm/gtx/orthonormalize.hpp +++ b/glm/gtx/orthonormalize.hpp @@ -34,13 +34,13 @@ namespace glm /// Returns the orthonormalized matrix of m. /// /// @see gtx_orthonormalize - template + template GLM_FUNC_DECL mat<3, 3, T, P> orthonormalize(mat<3, 3, T, P> const & m); /// Orthonormalizes x according y. /// /// @see gtx_orthonormalize - template + template GLM_FUNC_DECL vec<3, T, P> orthonormalize(vec<3, T, P> const & x, vec<3, T, P> const & y); /// @} diff --git a/glm/gtx/orthonormalize.inl b/glm/gtx/orthonormalize.inl index ebdee8c6..5d7b07a8 100644 --- a/glm/gtx/orthonormalize.inl +++ b/glm/gtx/orthonormalize.inl @@ -3,7 +3,7 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> orthonormalize(mat<3, 3, T, P> const & m) { mat<3, 3, T, P> r = m; @@ -22,7 +22,7 @@ namespace glm return r; } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> orthonormalize(vec<3, T, P> const & x, vec<3, T, P> const & y) { return normalize(x - y * dot(y, x)); diff --git a/glm/gtx/perpendicular.hpp b/glm/gtx/perpendicular.hpp index 7fe3f5bb..6402a211 100644 --- a/glm/gtx/perpendicular.hpp +++ b/glm/gtx/perpendicular.hpp @@ -32,10 +32,8 @@ namespace glm //! Projects x a perpendicular axis of Normal. //! From GLM_GTX_perpendicular extension. - template - GLM_FUNC_DECL vecType perp( - vecType const & x, - vecType const & Normal); + template + GLM_FUNC_DECL genType perp(genType const& x, genType const& Normal); /// @} }//namespace glm diff --git a/glm/gtx/perpendicular.inl b/glm/gtx/perpendicular.inl index e490bdd9..3b99eed8 100644 --- a/glm/gtx/perpendicular.inl +++ b/glm/gtx/perpendicular.inl @@ -3,12 +3,8 @@ namespace glm { - template - GLM_FUNC_QUALIFIER vecType perp - ( - vecType const & x, - vecType const & Normal - ) + template + GLM_FUNC_QUALIFIER genType perp(genType const& x, genType const& Normal) { return x - proj(x, Normal); } diff --git a/glm/gtx/polar_coordinates.hpp b/glm/gtx/polar_coordinates.hpp index a25fddc2..2c005856 100644 --- a/glm/gtx/polar_coordinates.hpp +++ b/glm/gtx/polar_coordinates.hpp @@ -31,14 +31,14 @@ namespace glm /// Convert Euclidean to Polar coordinates, x is the xz distance, y, the latitude and z the longitude. /// /// @see gtx_polar_coordinates - template + template GLM_FUNC_DECL vec<3, T, P> polar( vec<3, T, P> const & euclidean); /// Convert Polar to Euclidean coordinates. /// /// @see gtx_polar_coordinates - template + template GLM_FUNC_DECL vec<3, T, P> euclidean( vec<2, T, P> const & polar); diff --git a/glm/gtx/polar_coordinates.inl b/glm/gtx/polar_coordinates.inl index c4e394f5..bb0d5b34 100644 --- a/glm/gtx/polar_coordinates.inl +++ b/glm/gtx/polar_coordinates.inl @@ -3,7 +3,7 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER vec<3, T, P> polar ( vec<3, T, P> const & euclidean @@ -19,7 +19,7 @@ namespace glm xz_dist); // xz distance } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> euclidean ( vec<2, T, P> const & polar diff --git a/glm/gtx/projection.hpp b/glm/gtx/projection.hpp index cab35bf9..a984f419 100644 --- a/glm/gtx/projection.hpp +++ b/glm/gtx/projection.hpp @@ -31,8 +31,8 @@ namespace glm /// Projects x on Normal. /// /// @see gtx_projection - template - GLM_FUNC_DECL vecType proj(vecType const & x, vecType const & Normal); + template + GLM_FUNC_DECL genType proj(genType const& x, genType const& Normal); /// @} }//namespace glm diff --git a/glm/gtx/projection.inl b/glm/gtx/projection.inl index 8368669b..90950f8b 100644 --- a/glm/gtx/projection.inl +++ b/glm/gtx/projection.inl @@ -3,8 +3,8 @@ namespace glm { - template - GLM_FUNC_QUALIFIER vecType proj(vecType const & x, vecType const & Normal) + template + GLM_FUNC_QUALIFIER genType proj(genType const& x, genType const& Normal) { return glm::dot(x, Normal) / glm::dot(Normal, Normal) * Normal; } diff --git a/glm/gtx/quaternion.hpp b/glm/gtx/quaternion.hpp index 5497c8a3..c9fb694f 100644 --- a/glm/gtx/quaternion.hpp +++ b/glm/gtx/quaternion.hpp @@ -35,13 +35,13 @@ namespace glm /// Create an identity quaternion. /// /// @see gtx_quaternion - template + template GLM_FUNC_DECL tquat quat_identity(); /// Compute a cross product between a quaternion and a vector. /// /// @see gtx_quaternion - template + template GLM_FUNC_DECL vec<3, T, P> cross( tquat const & q, vec<3, T, P> const & v); @@ -49,7 +49,7 @@ namespace glm //! Compute a cross product between a vector and a quaternion. /// /// @see gtx_quaternion - template + template GLM_FUNC_DECL vec<3, T, P> cross( vec<3, T, P> const & v, tquat const & q); @@ -58,7 +58,7 @@ namespace glm //! q1 and q2 are control points; s1 and s2 are intermediate control points. /// /// @see gtx_quaternion - template + template GLM_FUNC_DECL tquat squad( tquat const& q1, tquat const& q2, @@ -69,7 +69,7 @@ namespace glm //! Returns an intermediate control point for squad interpolation. /// /// @see gtx_quaternion - template + template GLM_FUNC_DECL tquat intermediate( tquat const& prev, tquat const& curr, @@ -78,21 +78,21 @@ namespace glm //! Returns a exp of a quaternion. /// /// @see gtx_quaternion - template + template GLM_FUNC_DECL tquat exp( tquat const& q); //! Returns a log of a quaternion. /// /// @see gtx_quaternion - template + template GLM_FUNC_DECL tquat log( tquat const& q); /// Returns x raised to the y power. /// /// @see gtx_quaternion - template + template GLM_FUNC_DECL tquat pow( tquat const& x, T const& y); @@ -100,14 +100,14 @@ namespace glm //! Returns quarternion square root. /// /// @see gtx_quaternion - //template + //template //tquat sqrt( // tquat const & q); //! Rotates a 3 components vector by a quaternion. /// /// @see gtx_quaternion - template + template GLM_FUNC_DECL vec<3, T, P> rotate( tquat const& q, vec<3, T, P> const& v); @@ -115,7 +115,7 @@ namespace glm /// Rotates a 4 components vector by a quaternion. /// /// @see gtx_quaternion - template + template GLM_FUNC_DECL vec<4, T, P> rotate( tquat const& q, vec<4, T, P> const& v); @@ -123,42 +123,42 @@ namespace glm /// Extract the real component of a quaternion. /// /// @see gtx_quaternion - template + template GLM_FUNC_DECL T extractRealComponent( tquat const& q); /// Converts a quaternion to a 3 * 3 matrix. /// /// @see gtx_quaternion - template + template GLM_FUNC_DECL mat<3, 3, T, P> toMat3( tquat const& x){return mat3_cast(x);} /// Converts a quaternion to a 4 * 4 matrix. /// /// @see gtx_quaternion - template + template GLM_FUNC_DECL mat<4, 4, T, P> toMat4( tquat const& x){return mat4_cast(x);} /// Converts a 3 * 3 matrix to a quaternion. /// /// @see gtx_quaternion - template + template GLM_FUNC_DECL tquat toQuat( mat<3, 3, T, P> const& x){return quat_cast(x);} /// Converts a 4 * 4 matrix to a quaternion. /// /// @see gtx_quaternion - template + template GLM_FUNC_DECL tquat toQuat( mat<4, 4, T, P> const& x){return quat_cast(x);} /// Quaternion interpolation using the rotation short path. /// /// @see gtx_quaternion - template + template GLM_FUNC_DECL tquat shortMix( tquat const& x, tquat const& y, @@ -167,7 +167,7 @@ namespace glm /// Quaternion normalized linear interpolation. /// /// @see gtx_quaternion - template + template GLM_FUNC_DECL tquat fastMix( tquat const& x, tquat const& y, @@ -178,7 +178,7 @@ namespace glm /// param dest vector, needs to be normalized /// /// @see gtx_quaternion - template + template GLM_FUNC_DECL tquat rotation( vec<3, T, P> const& orig, vec<3, T, P> const& dest); @@ -187,7 +187,7 @@ namespace glm /// /// @param direction Desired direction of the camera. /// @param up Up vector, how the camera is oriented. Typically (0, 1, 0). - template + template GLM_FUNC_DECL tquat quatLookAt( vec<3, T, P> const& direction, vec<3, T, P> const& up); @@ -196,17 +196,16 @@ namespace glm /// /// @param direction Desired direction of the camera. /// @param up Up vector, how the camera is oriented. Typically (0, 1, 0). - template + template GLM_FUNC_DECL tquat quatLookAtRH( vec<3, T, P> const& direction, vec<3, T, P> const& up); /// Build a left-handed look at quaternion. /// - /// @param eye Position of the camera /// @param direction Desired direction onto which the +z-axis gets mapped /// @param up Up vector, how the camera is oriented. Typically (0, 1, 0). - template + template GLM_FUNC_DECL tquat quatLookAtLH( vec<3, T, P> const& direction, vec<3, T, P> const& up); @@ -214,7 +213,7 @@ namespace glm /// Returns the squared length of x. /// /// @see gtx_quaternion - template + template GLM_FUNC_DECL T length2(tquat const & q); /// @} diff --git a/glm/gtx/quaternion.inl b/glm/gtx/quaternion.inl index aa71634b..4e0c0204 100644 --- a/glm/gtx/quaternion.inl +++ b/glm/gtx/quaternion.inl @@ -6,25 +6,25 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER tquat quat_identity() { return tquat(static_cast(1), static_cast(0), static_cast(0), static_cast(0)); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> cross(vec<3, T, P> const& v, tquat const& q) { return inverse(q) * v; } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> cross(tquat const& q, vec<3, T, P> const& v) { return q * v; } - template + template GLM_FUNC_QUALIFIER tquat squad ( tquat const & q1, @@ -36,7 +36,7 @@ namespace glm return mix(mix(q1, q2, h), mix(s1, s2, h), static_cast(2) * (static_cast(1) - h) * h); } - template + template GLM_FUNC_QUALIFIER tquat intermediate ( tquat const & prev, @@ -48,7 +48,7 @@ namespace glm return exp((log(next + invQuat) + log(prev + invQuat)) / static_cast(-4)) * curr; } - template + template GLM_FUNC_QUALIFIER tquat exp(tquat const& q) { vec<3, T, P> u(q.x, q.y, q.z); @@ -60,7 +60,7 @@ namespace glm return tquat(cos(Angle), sin(Angle) * v); } - template + template GLM_FUNC_QUALIFIER tquat log(tquat const& q) { vec<3, T, P> u(q.x, q.y, q.z); @@ -83,7 +83,7 @@ namespace glm } } - template + template GLM_FUNC_QUALIFIER tquat pow(tquat const& x, T const& y) { //Raising to the power of 0 should yield 1 @@ -107,19 +107,19 @@ namespace glm return tquat(cos(NewAngle) * magnitude * Mag, x.x * Div * Mag, x.y * Div * Mag, x.z * Div * Mag); } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> rotate(tquat const& q, vec<3, T, P> const& v) { return q * v; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> rotate(tquat const& q, vec<4, T, P> const& v) { return q * v; } - template + template GLM_FUNC_QUALIFIER T extractRealComponent(tquat const& q) { T w = static_cast(1) - q.x * q.x - q.y * q.y - q.z * q.z; @@ -129,13 +129,13 @@ namespace glm return -sqrt(w); } - template + template GLM_FUNC_QUALIFIER T length2(tquat const& q) { return q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w; } - template + template GLM_FUNC_QUALIFIER tquat shortMix(tquat const& x, tquat const& y, T const& a) { if(a <= static_cast(0)) return x; @@ -172,13 +172,13 @@ namespace glm k0 * x.z + k1 * y2.z); } - template + template GLM_FUNC_QUALIFIER tquat fastMix(tquat const& x, tquat const& y, T const & a) { return glm::normalize(x * (static_cast(1) - a) + (y * a)); } - template + template GLM_FUNC_QUALIFIER tquat rotation(vec<3, T, P> const& orig, vec<3, T, P> const& dest) { T cosTheta = dot(orig, dest); @@ -215,7 +215,7 @@ namespace glm rotationAxis.z * invs); } - template + template GLM_FUNC_QUALIFIER tquat quatLookAt(vec<3, T, P> const& direction, vec<3, T, P> const& up) { # if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED @@ -225,7 +225,7 @@ namespace glm # endif } - template + template GLM_FUNC_QUALIFIER tquat quatLookAtRH(vec<3, T, P> const& direction, vec<3, T, P> const& up) { mat<3, 3, T, P> Result; @@ -237,7 +237,7 @@ namespace glm return quat_cast(Result); } - template + template GLM_FUNC_QUALIFIER tquat quatLookAtLH(vec<3, T, P> const& direction, vec<3, T, P> const& up) { mat<3, 3, T, P> Result; diff --git a/glm/gtx/range.hpp b/glm/gtx/range.hpp index 0877b2e4..98c294de 100644 --- a/glm/gtx/range.hpp +++ b/glm/gtx/range.hpp @@ -31,25 +31,25 @@ namespace glm /// @addtogroup gtx_range /// @{ - template + template inline length_t components(vec<1, T, P> const & v) { return v.length(); } - template + template inline length_t components(vec<2, T, P> const & v) { return v.length(); } - template + template inline length_t components(vec<3, T, P> const & v) { return v.length(); } - template + template inline length_t components(vec<4, T, P> const & v) { return v.length(); diff --git a/glm/gtx/rotate_normalized_axis.hpp b/glm/gtx/rotate_normalized_axis.hpp index ec9852d8..6a384ec8 100644 --- a/glm/gtx/rotate_normalized_axis.hpp +++ b/glm/gtx/rotate_normalized_axis.hpp @@ -43,7 +43,7 @@ namespace glm /// @see - rotate(T angle, T x, T y, T z) /// @see - rotate(mat<4, 4, T, P> const & m, T angle, T x, T y, T z) /// @see - rotate(T angle, vec<3, T, P> const & v) - template + template GLM_FUNC_DECL mat<4, 4, T, P> rotateNormalizedAxis( mat<4, 4, T, P> const& m, T const & angle, @@ -56,7 +56,7 @@ namespace glm /// @param axis Normalized axis of the rotation, must be normalized. /// /// @see gtx_rotate_normalized_axis - template + template GLM_FUNC_DECL tquat rotateNormalizedAxis( tquat const & q, T const & angle, diff --git a/glm/gtx/rotate_normalized_axis.inl b/glm/gtx/rotate_normalized_axis.inl index 0727fbd0..4a99fee7 100644 --- a/glm/gtx/rotate_normalized_axis.inl +++ b/glm/gtx/rotate_normalized_axis.inl @@ -3,7 +3,7 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> rotateNormalizedAxis ( mat<4, 4, T, P> const& m, @@ -40,7 +40,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER tquat rotateNormalizedAxis ( tquat const & q, diff --git a/glm/gtx/rotate_vector.hpp b/glm/gtx/rotate_vector.hpp index 3f076d94..d74c091d 100644 --- a/glm/gtx/rotate_vector.hpp +++ b/glm/gtx/rotate_vector.hpp @@ -37,7 +37,7 @@ namespace glm /// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1]. /// /// @see gtx_rotate_vector - template + template GLM_FUNC_DECL vec<3, T, P> slerp( vec<3, T, P> const & x, vec<3, T, P> const & y, @@ -45,14 +45,14 @@ namespace glm //! Rotate a two dimensional vector. //! From GLM_GTX_rotate_vector extension. - template + template GLM_FUNC_DECL vec<2, T, P> rotate( vec<2, T, P> const & v, T const & angle); //! Rotate a three dimensional vector around an axis. //! From GLM_GTX_rotate_vector extension. - template + template GLM_FUNC_DECL vec<3, T, P> rotate( vec<3, T, P> const & v, T const & angle, @@ -60,7 +60,7 @@ namespace glm //! Rotate a four dimensional vector around an axis. //! From GLM_GTX_rotate_vector extension. - template + template GLM_FUNC_DECL vec<4, T, P> rotate( vec<4, T, P> const & v, T const & angle, @@ -68,49 +68,49 @@ namespace glm //! Rotate a three dimensional vector around the X axis. //! From GLM_GTX_rotate_vector extension. - template + template GLM_FUNC_DECL vec<3, T, P> rotateX( vec<3, T, P> const & v, T const & angle); //! Rotate a three dimensional vector around the Y axis. //! From GLM_GTX_rotate_vector extension. - template + template GLM_FUNC_DECL vec<3, T, P> rotateY( vec<3, T, P> const & v, T const & angle); //! Rotate a three dimensional vector around the Z axis. //! From GLM_GTX_rotate_vector extension. - template + template GLM_FUNC_DECL vec<3, T, P> rotateZ( vec<3, T, P> const & v, T const & angle); //! Rotate a four dimensional vector around the X axis. //! From GLM_GTX_rotate_vector extension. - template + template GLM_FUNC_DECL vec<4, T, P> rotateX( vec<4, T, P> const & v, T const & angle); //! Rotate a four dimensional vector around the Y axis. //! From GLM_GTX_rotate_vector extension. - template + template GLM_FUNC_DECL vec<4, T, P> rotateY( vec<4, T, P> const & v, T const & angle); //! Rotate a four dimensional vector around the Z axis. //! From GLM_GTX_rotate_vector extension. - template + template GLM_FUNC_DECL vec<4, T, P> rotateZ( vec<4, T, P> const & v, T const & angle); //! Build a rotation matrix from a normal and a up vector. //! From GLM_GTX_rotate_vector extension. - template + template GLM_FUNC_DECL mat<4, 4, T, P> orientation( vec<3, T, P> const & Normal, vec<3, T, P> const & Up); diff --git a/glm/gtx/rotate_vector.inl b/glm/gtx/rotate_vector.inl index 7361c37d..d9db3f32 100644 --- a/glm/gtx/rotate_vector.inl +++ b/glm/gtx/rotate_vector.inl @@ -3,7 +3,7 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER vec<3, T, P> slerp ( vec<3, T, P> const & x, @@ -25,7 +25,7 @@ namespace glm return x * t1 + y * t2; } - template + template GLM_FUNC_QUALIFIER vec<2, T, P> rotate ( vec<2, T, P> const & v, @@ -41,7 +41,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> rotate ( vec<3, T, P> const & v, @@ -52,7 +52,7 @@ namespace glm return mat<3, 3, T, P>(glm::rotate(angle, normal)) * v; } /* - template + template GLM_FUNC_QUALIFIER vec<3, T, P> rotateGTX( const vec<3, T, P>& x, T angle, @@ -63,7 +63,7 @@ namespace glm return x * Cos + ((x * normal) * (T(1) - Cos)) * normal + cross(x, normal) * Sin; } */ - template + template GLM_FUNC_QUALIFIER vec<4, T, P> rotate ( vec<4, T, P> const & v, @@ -74,7 +74,7 @@ namespace glm return rotate(angle, normal) * v; } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> rotateX ( vec<3, T, P> const & v, @@ -90,7 +90,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> rotateY ( vec<3, T, P> const & v, @@ -106,7 +106,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER vec<3, T, P> rotateZ ( vec<3, T, P> const & v, @@ -122,7 +122,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> rotateX ( vec<4, T, P> const & v, @@ -138,7 +138,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> rotateY ( vec<4, T, P> const & v, @@ -154,7 +154,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER vec<4, T, P> rotateZ ( vec<4, T, P> const & v, @@ -170,7 +170,7 @@ namespace glm return Result; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> orientation ( vec<3, T, P> const & Normal, diff --git a/glm/gtx/string_cast.inl b/glm/gtx/string_cast.inl index 44a2aa5a..453dff48 100644 --- a/glm/gtx/string_cast.inl +++ b/glm/gtx/string_cast.inl @@ -141,7 +141,7 @@ namespace detail struct compute_to_string {}; - template + template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<1, bool, P> const & x) @@ -151,7 +151,7 @@ namespace detail } }; - template + template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<2, bool, P> const & x) @@ -162,7 +162,7 @@ namespace detail } }; - template + template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<3, bool, P> const & x) @@ -174,7 +174,7 @@ namespace detail } }; - template + template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<4, bool, P> const & x) @@ -187,7 +187,7 @@ namespace detail } }; - template + template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<1, T, P> const & x) @@ -203,7 +203,7 @@ namespace detail } }; - template + template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<2, T, P> const & x) @@ -220,7 +220,7 @@ namespace detail } }; - template + template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<3, T, P> const & x) @@ -238,7 +238,7 @@ namespace detail } }; - template + template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(vec<4, T, P> const & x) @@ -258,7 +258,7 @@ namespace detail }; - template + template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<2, 2, T, P> const & x) @@ -276,7 +276,7 @@ namespace detail } }; - template + template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<2, 3, T, P> const & x) @@ -294,7 +294,7 @@ namespace detail } }; - template + template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<2, 4, T, P> const & x) @@ -312,7 +312,7 @@ namespace detail } }; - template + template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<3, 2, T, P> const & x) @@ -332,7 +332,7 @@ namespace detail } }; - template + template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<3, 3, T, P> const & x) @@ -352,7 +352,7 @@ namespace detail } }; - template + template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<3, 4, T, P> const & x) @@ -372,7 +372,7 @@ namespace detail } }; - template + template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<4, 2, T, P> const & x) @@ -394,7 +394,7 @@ namespace detail } }; - template + template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<4, 3, T, P> const & x) @@ -416,7 +416,7 @@ namespace detail } }; - template + template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(mat<4, 4, T, P> const & x) @@ -439,7 +439,7 @@ namespace detail }; - template + template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(tquat const & x) @@ -458,7 +458,7 @@ namespace detail } }; - template + template struct compute_to_string > { GLM_FUNC_QUALIFIER static std::string call(tdualquat const & x) diff --git a/glm/gtx/transform.hpp b/glm/gtx/transform.hpp index f6023c65..fd8870fe 100644 --- a/glm/gtx/transform.hpp +++ b/glm/gtx/transform.hpp @@ -35,14 +35,14 @@ namespace glm /// Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars. /// @see gtc_matrix_transform /// @see gtx_transform - template + template GLM_FUNC_DECL mat<4, 4, T, P> translate( vec<3, T, P> const & v); /// Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in radians. /// @see gtc_matrix_transform /// @see gtx_transform - template + template GLM_FUNC_DECL mat<4, 4, T, P> rotate( T angle, vec<3, T, P> const & v); @@ -50,7 +50,7 @@ namespace glm /// Transforms a matrix with a scale 4 * 4 matrix created from a vector of 3 components. /// @see gtc_matrix_transform /// @see gtx_transform - template + template GLM_FUNC_DECL mat<4, 4, T, P> scale( vec<3, T, P> const & v); diff --git a/glm/gtx/transform.inl b/glm/gtx/transform.inl index bd855049..44fd9aa3 100644 --- a/glm/gtx/transform.inl +++ b/glm/gtx/transform.inl @@ -3,19 +3,19 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> translate(vec<3, T, P> const & v) { return translate(mat<4, 4, T, P>(static_cast(1)), v); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> rotate(T angle, vec<3, T, P> const & v) { return rotate(mat<4, 4, T, P>(static_cast(1)), angle, v); } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> scale(vec<3, T, P> const & v) { return scale(mat<4, 4, T, P>(static_cast(1)), v); diff --git a/glm/gtx/transform2.hpp b/glm/gtx/transform2.hpp index 957bd3a8..66343153 100644 --- a/glm/gtx/transform2.hpp +++ b/glm/gtx/transform2.hpp @@ -32,21 +32,21 @@ namespace glm //! Transforms a matrix with a shearing on X axis. //! From GLM_GTX_transform2 extension. - template + template GLM_FUNC_DECL mat<3, 3, T, P> shearX2D( mat<3, 3, T, P> const& m, T y); //! Transforms a matrix with a shearing on Y axis. //! From GLM_GTX_transform2 extension. - template + template GLM_FUNC_DECL mat<3, 3, T, P> shearY2D( mat<3, 3, T, P> const& m, T x); //! Transforms a matrix with a shearing on X axis //! From GLM_GTX_transform2 extension. - template + template GLM_FUNC_DECL mat<4, 4, T, P> shearX3D( const mat<4, 4, T, P> & m, T y, @@ -54,7 +54,7 @@ namespace glm //! Transforms a matrix with a shearing on Y axis. //! From GLM_GTX_transform2 extension. - template + template GLM_FUNC_DECL mat<4, 4, T, P> shearY3D( const mat<4, 4, T, P> & m, T x, @@ -62,7 +62,7 @@ namespace glm //! Transforms a matrix with a shearing on Z axis. //! From GLM_GTX_transform2 extension. - template + template GLM_FUNC_DECL mat<4, 4, T, P> shearZ3D( const mat<4, 4, T, P> & m, T x, @@ -78,28 +78,28 @@ namespace glm //! Build planar projection matrix along normal axis. //! From GLM_GTX_transform2 extension. - template + template GLM_FUNC_DECL mat<3, 3, T, P> proj2D( const mat<3, 3, T, P> & m, const vec<3, T, P>& normal); //! Build planar projection matrix along normal axis. //! From GLM_GTX_transform2 extension. - template + template GLM_FUNC_DECL mat<4, 4, T, P> proj3D( const mat<4, 4, T, P> & m, const vec<3, T, P>& normal); //! Build a scale bias matrix. //! From GLM_GTX_transform2 extension. - template + template GLM_FUNC_DECL mat<4, 4, valType, P> scaleBias( valType scale, valType bias); //! Build a scale bias matrix. //! From GLM_GTX_transform2 extension. - template + template GLM_FUNC_DECL mat<4, 4, valType, P> scaleBias( mat<4, 4, valType, P> const & m, valType scale, diff --git a/glm/gtx/transform2.inl b/glm/gtx/transform2.inl index 557e93cd..4d71fa97 100644 --- a/glm/gtx/transform2.inl +++ b/glm/gtx/transform2.inl @@ -3,7 +3,7 @@ namespace glm { - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> shearX2D(mat<3, 3, T, P> const& m, T s) { mat<3, 3, T, P> r(1); @@ -11,7 +11,7 @@ namespace glm return m * r; } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> shearY2D(mat<3, 3, T, P> const& m, T s) { mat<3, 3, T, P> r(1); @@ -19,7 +19,7 @@ namespace glm return m * r; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> shearX3D(mat<4, 4, T, P> const& m, T s, T t) { mat<4, 4, T, P> r(1); @@ -28,7 +28,7 @@ namespace glm return m * r; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> shearY3D(mat<4, 4, T, P> const& m, T s, T t) { mat<4, 4, T, P> r(1); @@ -37,7 +37,7 @@ namespace glm return m * r; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> shearZ3D(mat<4, 4, T, P> const& m, T s, T t) { mat<4, 4, T, P> r(1); @@ -46,7 +46,7 @@ namespace glm return m * r; } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> reflect2D(mat<3, 3, T, P> const& m, vec<3, T, P> const& normal) { mat<3, 3, T, P> r(static_cast(1)); @@ -57,7 +57,7 @@ namespace glm return m * r; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> reflect3D(mat<4, 4, T, P> const& m, vec<3, T, P> const& normal) { mat<4, 4, T, P> r(static_cast(1)); @@ -75,7 +75,7 @@ namespace glm return m * r; } - template + template GLM_FUNC_QUALIFIER mat<3, 3, T, P> proj2D( const mat<3, 3, T, P>& m, const vec<3, T, P>& normal) @@ -88,7 +88,7 @@ namespace glm return m * r; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> proj3D( const mat<4, 4, T, P>& m, const vec<3, T, P>& normal) @@ -106,7 +106,7 @@ namespace glm return m * r; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> scaleBias(T scale, T bias) { mat<4, 4, T, P> result; @@ -117,7 +117,7 @@ namespace glm return result; } - template + template GLM_FUNC_QUALIFIER mat<4, 4, T, P> scaleBias(mat<4, 4, T, P> const& m, T scale, T bias) { return m * scaleBias(scale, bias); diff --git a/glm/gtx/type_aligned.hpp b/glm/gtx/type_aligned.hpp index 4e9effee..5b3d8614 100644 --- a/glm/gtx/type_aligned.hpp +++ b/glm/gtx/type_aligned.hpp @@ -34,291 +34,291 @@ namespace glm /// @addtogroup gtx_type_aligned /// @{ - /// Low precision 8 bit signed integer aligned scalar type. + /// Low qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int8, aligned_lowp_int8, 1); - /// Low precision 16 bit signed integer aligned scalar type. + /// Low qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int16, aligned_lowp_int16, 2); - /// Low precision 32 bit signed integer aligned scalar type. + /// Low qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int32, aligned_lowp_int32, 4); - /// Low precision 64 bit signed integer aligned scalar type. + /// Low qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int64, aligned_lowp_int64, 8); - /// Low precision 8 bit signed integer aligned scalar type. + /// Low qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int8_t, aligned_lowp_int8_t, 1); - /// Low precision 16 bit signed integer aligned scalar type. + /// Low qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int16_t, aligned_lowp_int16_t, 2); - /// Low precision 32 bit signed integer aligned scalar type. + /// Low qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int32_t, aligned_lowp_int32_t, 4); - /// Low precision 64 bit signed integer aligned scalar type. + /// Low qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_int64_t, aligned_lowp_int64_t, 8); - /// Low precision 8 bit signed integer aligned scalar type. + /// Low qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_i8, aligned_lowp_i8, 1); - /// Low precision 16 bit signed integer aligned scalar type. + /// Low qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_i16, aligned_lowp_i16, 2); - /// Low precision 32 bit signed integer aligned scalar type. + /// Low qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_i32, aligned_lowp_i32, 4); - /// Low precision 64 bit signed integer aligned scalar type. + /// Low qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_i64, aligned_lowp_i64, 8); - /// Medium precision 8 bit signed integer aligned scalar type. + /// Medium qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int8, aligned_mediump_int8, 1); - /// Medium precision 16 bit signed integer aligned scalar type. + /// Medium qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int16, aligned_mediump_int16, 2); - /// Medium precision 32 bit signed integer aligned scalar type. + /// Medium qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int32, aligned_mediump_int32, 4); - /// Medium precision 64 bit signed integer aligned scalar type. + /// Medium qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int64, aligned_mediump_int64, 8); - /// Medium precision 8 bit signed integer aligned scalar type. + /// Medium qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int8_t, aligned_mediump_int8_t, 1); - /// Medium precision 16 bit signed integer aligned scalar type. + /// Medium qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int16_t, aligned_mediump_int16_t, 2); - /// Medium precision 32 bit signed integer aligned scalar type. + /// Medium qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int32_t, aligned_mediump_int32_t, 4); - /// Medium precision 64 bit signed integer aligned scalar type. + /// Medium qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_int64_t, aligned_mediump_int64_t, 8); - /// Medium precision 8 bit signed integer aligned scalar type. + /// Medium qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_i8, aligned_mediump_i8, 1); - /// Medium precision 16 bit signed integer aligned scalar type. + /// Medium qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_i16, aligned_mediump_i16, 2); - /// Medium precision 32 bit signed integer aligned scalar type. + /// Medium qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_i32, aligned_mediump_i32, 4); - /// Medium precision 64 bit signed integer aligned scalar type. + /// Medium qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_i64, aligned_mediump_i64, 8); - /// High precision 8 bit signed integer aligned scalar type. + /// High qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int8, aligned_highp_int8, 1); - /// High precision 16 bit signed integer aligned scalar type. + /// High qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int16, aligned_highp_int16, 2); - /// High precision 32 bit signed integer aligned scalar type. + /// High qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int32, aligned_highp_int32, 4); - /// High precision 64 bit signed integer aligned scalar type. + /// High qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int64, aligned_highp_int64, 8); - /// High precision 8 bit signed integer aligned scalar type. + /// High qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int8_t, aligned_highp_int8_t, 1); - /// High precision 16 bit signed integer aligned scalar type. + /// High qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int16_t, aligned_highp_int16_t, 2); - /// High precision 32 bit signed integer aligned scalar type. + /// High qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int32_t, aligned_highp_int32_t, 4); - /// High precision 64 bit signed integer aligned scalar type. + /// High qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_int64_t, aligned_highp_int64_t, 8); - /// High precision 8 bit signed integer aligned scalar type. + /// High qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_i8, aligned_highp_i8, 1); - /// High precision 16 bit signed integer aligned scalar type. + /// High qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_i16, aligned_highp_i16, 2); - /// High precision 32 bit signed integer aligned scalar type. + /// High qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_i32, aligned_highp_i32, 4); - /// High precision 64 bit signed integer aligned scalar type. + /// High qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_i64, aligned_highp_i64, 8); - /// Default precision 8 bit signed integer aligned scalar type. + /// Default qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int8, aligned_int8, 1); - /// Default precision 16 bit signed integer aligned scalar type. + /// Default qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int16, aligned_int16, 2); - /// Default precision 32 bit signed integer aligned scalar type. + /// Default qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int32, aligned_int32, 4); - /// Default precision 64 bit signed integer aligned scalar type. + /// Default qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int64, aligned_int64, 8); - /// Default precision 8 bit signed integer aligned scalar type. + /// Default qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int8_t, aligned_int8_t, 1); - /// Default precision 16 bit signed integer aligned scalar type. + /// Default qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int16_t, aligned_int16_t, 2); - /// Default precision 32 bit signed integer aligned scalar type. + /// Default qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int32_t, aligned_int32_t, 4); - /// Default precision 64 bit signed integer aligned scalar type. + /// Default qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(int64_t, aligned_int64_t, 8); - /// Default precision 8 bit signed integer aligned scalar type. + /// Default qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i8, aligned_i8, 1); - /// Default precision 16 bit signed integer aligned scalar type. + /// Default qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i16, aligned_i16, 2); - /// Default precision 32 bit signed integer aligned scalar type. + /// Default qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i32, aligned_i32, 4); - /// Default precision 64 bit signed integer aligned scalar type. + /// Default qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i64, aligned_i64, 8); - /// Default precision 32 bit signed integer aligned scalar type. + /// Default qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(ivec1, aligned_ivec1, 4); - /// Default precision 32 bit signed integer aligned vector of 2 components type. + /// Default qualifier 32 bit signed integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(ivec2, aligned_ivec2, 8); - /// Default precision 32 bit signed integer aligned vector of 3 components type. + /// Default qualifier 32 bit signed integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(ivec3, aligned_ivec3, 16); - /// Default precision 32 bit signed integer aligned vector of 4 components type. + /// Default qualifier 32 bit signed integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(ivec4, aligned_ivec4, 16); - /// Default precision 8 bit signed integer aligned scalar type. + /// Default qualifier 8 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i8vec1, aligned_i8vec1, 1); - /// Default precision 8 bit signed integer aligned vector of 2 components type. + /// Default qualifier 8 bit signed integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i8vec2, aligned_i8vec2, 2); - /// Default precision 8 bit signed integer aligned vector of 3 components type. + /// Default qualifier 8 bit signed integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i8vec3, aligned_i8vec3, 4); - /// Default precision 8 bit signed integer aligned vector of 4 components type. + /// Default qualifier 8 bit signed integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i8vec4, aligned_i8vec4, 4); - /// Default precision 16 bit signed integer aligned scalar type. + /// Default qualifier 16 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i16vec1, aligned_i16vec1, 2); - /// Default precision 16 bit signed integer aligned vector of 2 components type. + /// Default qualifier 16 bit signed integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i16vec2, aligned_i16vec2, 4); - /// Default precision 16 bit signed integer aligned vector of 3 components type. + /// Default qualifier 16 bit signed integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i16vec3, aligned_i16vec3, 8); - /// Default precision 16 bit signed integer aligned vector of 4 components type. + /// Default qualifier 16 bit signed integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i16vec4, aligned_i16vec4, 8); - /// Default precision 32 bit signed integer aligned scalar type. + /// Default qualifier 32 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i32vec1, aligned_i32vec1, 4); - /// Default precision 32 bit signed integer aligned vector of 2 components type. + /// Default qualifier 32 bit signed integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i32vec2, aligned_i32vec2, 8); - /// Default precision 32 bit signed integer aligned vector of 3 components type. + /// Default qualifier 32 bit signed integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i32vec3, aligned_i32vec3, 16); - /// Default precision 32 bit signed integer aligned vector of 4 components type. + /// Default qualifier 32 bit signed integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i32vec4, aligned_i32vec4, 16); - /// Default precision 64 bit signed integer aligned scalar type. + /// Default qualifier 64 bit signed integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i64vec1, aligned_i64vec1, 8); - /// Default precision 64 bit signed integer aligned vector of 2 components type. + /// Default qualifier 64 bit signed integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i64vec2, aligned_i64vec2, 16); - /// Default precision 64 bit signed integer aligned vector of 3 components type. + /// Default qualifier 64 bit signed integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i64vec3, aligned_i64vec3, 32); - /// Default precision 64 bit signed integer aligned vector of 4 components type. + /// Default qualifier 64 bit signed integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(i64vec4, aligned_i64vec4, 32); @@ -326,291 +326,291 @@ namespace glm ///////////////////////////// // Unsigned int vector types - /// Low precision 8 bit unsigned integer aligned scalar type. + /// Low qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint8, aligned_lowp_uint8, 1); - /// Low precision 16 bit unsigned integer aligned scalar type. + /// Low qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint16, aligned_lowp_uint16, 2); - /// Low precision 32 bit unsigned integer aligned scalar type. + /// Low qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint32, aligned_lowp_uint32, 4); - /// Low precision 64 bit unsigned integer aligned scalar type. + /// Low qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint64, aligned_lowp_uint64, 8); - /// Low precision 8 bit unsigned integer aligned scalar type. + /// Low qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint8_t, aligned_lowp_uint8_t, 1); - /// Low precision 16 bit unsigned integer aligned scalar type. + /// Low qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint16_t, aligned_lowp_uint16_t, 2); - /// Low precision 32 bit unsigned integer aligned scalar type. + /// Low qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint32_t, aligned_lowp_uint32_t, 4); - /// Low precision 64 bit unsigned integer aligned scalar type. + /// Low qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_uint64_t, aligned_lowp_uint64_t, 8); - /// Low precision 8 bit unsigned integer aligned scalar type. + /// Low qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_u8, aligned_lowp_u8, 1); - /// Low precision 16 bit unsigned integer aligned scalar type. + /// Low qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_u16, aligned_lowp_u16, 2); - /// Low precision 32 bit unsigned integer aligned scalar type. + /// Low qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_u32, aligned_lowp_u32, 4); - /// Low precision 64 bit unsigned integer aligned scalar type. + /// Low qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(lowp_u64, aligned_lowp_u64, 8); - /// Medium precision 8 bit unsigned integer aligned scalar type. + /// Medium qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint8, aligned_mediump_uint8, 1); - /// Medium precision 16 bit unsigned integer aligned scalar type. + /// Medium qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint16, aligned_mediump_uint16, 2); - /// Medium precision 32 bit unsigned integer aligned scalar type. + /// Medium qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint32, aligned_mediump_uint32, 4); - /// Medium precision 64 bit unsigned integer aligned scalar type. + /// Medium qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint64, aligned_mediump_uint64, 8); - /// Medium precision 8 bit unsigned integer aligned scalar type. + /// Medium qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint8_t, aligned_mediump_uint8_t, 1); - /// Medium precision 16 bit unsigned integer aligned scalar type. + /// Medium qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint16_t, aligned_mediump_uint16_t, 2); - /// Medium precision 32 bit unsigned integer aligned scalar type. + /// Medium qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint32_t, aligned_mediump_uint32_t, 4); - /// Medium precision 64 bit unsigned integer aligned scalar type. + /// Medium qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_uint64_t, aligned_mediump_uint64_t, 8); - /// Medium precision 8 bit unsigned integer aligned scalar type. + /// Medium qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_u8, aligned_mediump_u8, 1); - /// Medium precision 16 bit unsigned integer aligned scalar type. + /// Medium qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_u16, aligned_mediump_u16, 2); - /// Medium precision 32 bit unsigned integer aligned scalar type. + /// Medium qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_u32, aligned_mediump_u32, 4); - /// Medium precision 64 bit unsigned integer aligned scalar type. + /// Medium qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mediump_u64, aligned_mediump_u64, 8); - /// High precision 8 bit unsigned integer aligned scalar type. + /// High qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint8, aligned_highp_uint8, 1); - /// High precision 16 bit unsigned integer aligned scalar type. + /// High qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint16, aligned_highp_uint16, 2); - /// High precision 32 bit unsigned integer aligned scalar type. + /// High qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint32, aligned_highp_uint32, 4); - /// High precision 64 bit unsigned integer aligned scalar type. + /// High qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint64, aligned_highp_uint64, 8); - /// High precision 8 bit unsigned integer aligned scalar type. + /// High qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint8_t, aligned_highp_uint8_t, 1); - /// High precision 16 bit unsigned integer aligned scalar type. + /// High qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint16_t, aligned_highp_uint16_t, 2); - /// High precision 32 bit unsigned integer aligned scalar type. + /// High qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint32_t, aligned_highp_uint32_t, 4); - /// High precision 64 bit unsigned integer aligned scalar type. + /// High qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_uint64_t, aligned_highp_uint64_t, 8); - /// High precision 8 bit unsigned integer aligned scalar type. + /// High qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_u8, aligned_highp_u8, 1); - /// High precision 16 bit unsigned integer aligned scalar type. + /// High qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_u16, aligned_highp_u16, 2); - /// High precision 32 bit unsigned integer aligned scalar type. + /// High qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_u32, aligned_highp_u32, 4); - /// High precision 64 bit unsigned integer aligned scalar type. + /// High qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(highp_u64, aligned_highp_u64, 8); - /// Default precision 8 bit unsigned integer aligned scalar type. + /// Default qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint8, aligned_uint8, 1); - /// Default precision 16 bit unsigned integer aligned scalar type. + /// Default qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint16, aligned_uint16, 2); - /// Default precision 32 bit unsigned integer aligned scalar type. + /// Default qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint32, aligned_uint32, 4); - /// Default precision 64 bit unsigned integer aligned scalar type. + /// Default qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint64, aligned_uint64, 8); - /// Default precision 8 bit unsigned integer aligned scalar type. + /// Default qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint8_t, aligned_uint8_t, 1); - /// Default precision 16 bit unsigned integer aligned scalar type. + /// Default qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint16_t, aligned_uint16_t, 2); - /// Default precision 32 bit unsigned integer aligned scalar type. + /// Default qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint32_t, aligned_uint32_t, 4); - /// Default precision 64 bit unsigned integer aligned scalar type. + /// Default qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uint64_t, aligned_uint64_t, 8); - /// Default precision 8 bit unsigned integer aligned scalar type. + /// Default qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u8, aligned_u8, 1); - /// Default precision 16 bit unsigned integer aligned scalar type. + /// Default qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u16, aligned_u16, 2); - /// Default precision 32 bit unsigned integer aligned scalar type. + /// Default qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u32, aligned_u32, 4); - /// Default precision 64 bit unsigned integer aligned scalar type. + /// Default qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u64, aligned_u64, 8); - /// Default precision 32 bit unsigned integer aligned scalar type. + /// Default qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uvec1, aligned_uvec1, 4); - /// Default precision 32 bit unsigned integer aligned vector of 2 components type. + /// Default qualifier 32 bit unsigned integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uvec2, aligned_uvec2, 8); - /// Default precision 32 bit unsigned integer aligned vector of 3 components type. + /// Default qualifier 32 bit unsigned integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uvec3, aligned_uvec3, 16); - /// Default precision 32 bit unsigned integer aligned vector of 4 components type. + /// Default qualifier 32 bit unsigned integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(uvec4, aligned_uvec4, 16); - /// Default precision 8 bit unsigned integer aligned scalar type. + /// Default qualifier 8 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u8vec1, aligned_u8vec1, 1); - /// Default precision 8 bit unsigned integer aligned vector of 2 components type. + /// Default qualifier 8 bit unsigned integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u8vec2, aligned_u8vec2, 2); - /// Default precision 8 bit unsigned integer aligned vector of 3 components type. + /// Default qualifier 8 bit unsigned integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u8vec3, aligned_u8vec3, 4); - /// Default precision 8 bit unsigned integer aligned vector of 4 components type. + /// Default qualifier 8 bit unsigned integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u8vec4, aligned_u8vec4, 4); - /// Default precision 16 bit unsigned integer aligned scalar type. + /// Default qualifier 16 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u16vec1, aligned_u16vec1, 2); - /// Default precision 16 bit unsigned integer aligned vector of 2 components type. + /// Default qualifier 16 bit unsigned integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u16vec2, aligned_u16vec2, 4); - /// Default precision 16 bit unsigned integer aligned vector of 3 components type. + /// Default qualifier 16 bit unsigned integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u16vec3, aligned_u16vec3, 8); - /// Default precision 16 bit unsigned integer aligned vector of 4 components type. + /// Default qualifier 16 bit unsigned integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u16vec4, aligned_u16vec4, 8); - /// Default precision 32 bit unsigned integer aligned scalar type. + /// Default qualifier 32 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u32vec1, aligned_u32vec1, 4); - /// Default precision 32 bit unsigned integer aligned vector of 2 components type. + /// Default qualifier 32 bit unsigned integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u32vec2, aligned_u32vec2, 8); - /// Default precision 32 bit unsigned integer aligned vector of 3 components type. + /// Default qualifier 32 bit unsigned integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u32vec3, aligned_u32vec3, 16); - /// Default precision 32 bit unsigned integer aligned vector of 4 components type. + /// Default qualifier 32 bit unsigned integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u32vec4, aligned_u32vec4, 16); - /// Default precision 64 bit unsigned integer aligned scalar type. + /// Default qualifier 64 bit unsigned integer aligned scalar type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u64vec1, aligned_u64vec1, 8); - /// Default precision 64 bit unsigned integer aligned vector of 2 components type. + /// Default qualifier 64 bit unsigned integer aligned vector of 2 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u64vec2, aligned_u64vec2, 16); - /// Default precision 64 bit unsigned integer aligned vector of 3 components type. + /// Default qualifier 64 bit unsigned integer aligned vector of 3 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u64vec3, aligned_u64vec3, 32); - /// Default precision 64 bit unsigned integer aligned vector of 4 components type. + /// Default qualifier 64 bit unsigned integer aligned vector of 4 components type. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(u64vec4, aligned_u64vec4, 32); @@ -618,114 +618,114 @@ namespace glm ////////////////////// // Float vector types - /// 32 bit single-precision floating-point aligned scalar. + /// 32 bit single-qualifier floating-point aligned scalar. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(float32, aligned_float32, 4); - /// 64 bit double-precision floating-point aligned scalar. + /// 64 bit double-qualifier floating-point aligned scalar. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(float64, aligned_float64, 8); - /// 32 bit single-precision floating-point aligned scalar. + /// 32 bit single-qualifier floating-point aligned scalar. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(float32_t, aligned_float32_t, 4); - /// 64 bit double-precision floating-point aligned scalar. + /// 64 bit double-qualifier floating-point aligned scalar. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(float64_t, aligned_float64_t, 8); - /// 32 bit single-precision floating-point aligned scalar. + /// 32 bit single-qualifier floating-point aligned scalar. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(float32, aligned_f32, 4); - /// 64 bit double-precision floating-point aligned scalar. + /// 64 bit double-qualifier floating-point aligned scalar. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(float64, aligned_f64, 8); - /// Single-precision floating-point aligned vector of 1 component. + /// Single-qualifier floating-point aligned vector of 1 component. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(vec1, aligned_vec1, 4); - /// Single-precision floating-point aligned vector of 2 components. + /// Single-qualifier floating-point aligned vector of 2 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(vec2, aligned_vec2, 8); - /// Single-precision floating-point aligned vector of 3 components. + /// Single-qualifier floating-point aligned vector of 3 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(vec3, aligned_vec3, 16); - /// Single-precision floating-point aligned vector of 4 components. + /// Single-qualifier floating-point aligned vector of 4 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(vec4, aligned_vec4, 16); - /// Single-precision floating-point aligned vector of 1 component. + /// Single-qualifier floating-point aligned vector of 1 component. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fvec1, aligned_fvec1, 4); - /// Single-precision floating-point aligned vector of 2 components. + /// Single-qualifier floating-point aligned vector of 2 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fvec2, aligned_fvec2, 8); - /// Single-precision floating-point aligned vector of 3 components. + /// Single-qualifier floating-point aligned vector of 3 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fvec3, aligned_fvec3, 16); - /// Single-precision floating-point aligned vector of 4 components. + /// Single-qualifier floating-point aligned vector of 4 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fvec4, aligned_fvec4, 16); - /// Single-precision floating-point aligned vector of 1 component. + /// Single-qualifier floating-point aligned vector of 1 component. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32vec1, aligned_f32vec1, 4); - /// Single-precision floating-point aligned vector of 2 components. + /// Single-qualifier floating-point aligned vector of 2 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32vec2, aligned_f32vec2, 8); - /// Single-precision floating-point aligned vector of 3 components. + /// Single-qualifier floating-point aligned vector of 3 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32vec3, aligned_f32vec3, 16); - /// Single-precision floating-point aligned vector of 4 components. + /// Single-qualifier floating-point aligned vector of 4 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32vec4, aligned_f32vec4, 16); - /// Double-precision floating-point aligned vector of 1 component. + /// Double-qualifier floating-point aligned vector of 1 component. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(dvec1, aligned_dvec1, 8); - /// Double-precision floating-point aligned vector of 2 components. + /// Double-qualifier floating-point aligned vector of 2 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(dvec2, aligned_dvec2, 16); - /// Double-precision floating-point aligned vector of 3 components. + /// Double-qualifier floating-point aligned vector of 3 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(dvec3, aligned_dvec3, 32); - /// Double-precision floating-point aligned vector of 4 components. + /// Double-qualifier floating-point aligned vector of 4 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(dvec4, aligned_dvec4, 32); - /// Double-precision floating-point aligned vector of 1 component. + /// Double-qualifier floating-point aligned vector of 1 component. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64vec1, aligned_f64vec1, 8); - /// Double-precision floating-point aligned vector of 2 components. + /// Double-qualifier floating-point aligned vector of 2 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64vec2, aligned_f64vec2, 16); - /// Double-precision floating-point aligned vector of 3 components. + /// Double-qualifier floating-point aligned vector of 3 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64vec3, aligned_f64vec3, 32); - /// Double-precision floating-point aligned vector of 4 components. + /// Double-qualifier floating-point aligned vector of 4 components. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64vec4, aligned_f64vec4, 32); @@ -733,210 +733,210 @@ namespace glm ////////////////////// // Float matrix types - /// Single-precision floating-point aligned 1x1 matrix. + /// Single-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef detail::tmat1 mat1; - /// Single-precision floating-point aligned 2x2 matrix. + /// Single-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mat2, aligned_mat2, 16); - /// Single-precision floating-point aligned 3x3 matrix. + /// Single-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mat3, aligned_mat3, 16); - /// Single-precision floating-point aligned 4x4 matrix. + /// Single-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mat4, aligned_mat4, 16); - /// Single-precision floating-point aligned 1x1 matrix. + /// Single-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef detail::tmat1x1 mat1; - /// Single-precision floating-point aligned 2x2 matrix. + /// Single-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mat2x2, aligned_mat2x2, 16); - /// Single-precision floating-point aligned 3x3 matrix. + /// Single-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mat3x3, aligned_mat3x3, 16); - /// Single-precision floating-point aligned 4x4 matrix. + /// Single-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(mat4x4, aligned_mat4x4, 16); - /// Single-precision floating-point aligned 1x1 matrix. + /// Single-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef detail::tmat1x1 fmat1; - /// Single-precision floating-point aligned 2x2 matrix. + /// Single-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat2x2, aligned_fmat2, 16); - /// Single-precision floating-point aligned 3x3 matrix. + /// Single-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat3x3, aligned_fmat3, 16); - /// Single-precision floating-point aligned 4x4 matrix. + /// Single-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat4x4, aligned_fmat4, 16); - /// Single-precision floating-point aligned 1x1 matrix. + /// Single-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef f32 fmat1x1; - /// Single-precision floating-point aligned 2x2 matrix. + /// Single-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat2x2, aligned_fmat2x2, 16); - /// Single-precision floating-point aligned 2x3 matrix. + /// Single-qualifier floating-point aligned 2x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat2x3, aligned_fmat2x3, 16); - /// Single-precision floating-point aligned 2x4 matrix. + /// Single-qualifier floating-point aligned 2x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat2x4, aligned_fmat2x4, 16); - /// Single-precision floating-point aligned 3x2 matrix. + /// Single-qualifier floating-point aligned 3x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat3x2, aligned_fmat3x2, 16); - /// Single-precision floating-point aligned 3x3 matrix. + /// Single-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat3x3, aligned_fmat3x3, 16); - /// Single-precision floating-point aligned 3x4 matrix. + /// Single-qualifier floating-point aligned 3x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat3x4, aligned_fmat3x4, 16); - /// Single-precision floating-point aligned 4x2 matrix. + /// Single-qualifier floating-point aligned 4x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat4x2, aligned_fmat4x2, 16); - /// Single-precision floating-point aligned 4x3 matrix. + /// Single-qualifier floating-point aligned 4x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat4x3, aligned_fmat4x3, 16); - /// Single-precision floating-point aligned 4x4 matrix. + /// Single-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fmat4x4, aligned_fmat4x4, 16); - /// Single-precision floating-point aligned 1x1 matrix. + /// Single-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef detail::tmat1x1 f32mat1; - /// Single-precision floating-point aligned 2x2 matrix. + /// Single-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat2x2, aligned_f32mat2, 16); - /// Single-precision floating-point aligned 3x3 matrix. + /// Single-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat3x3, aligned_f32mat3, 16); - /// Single-precision floating-point aligned 4x4 matrix. + /// Single-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat4x4, aligned_f32mat4, 16); - /// Single-precision floating-point aligned 1x1 matrix. + /// Single-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef f32 f32mat1x1; - /// Single-precision floating-point aligned 2x2 matrix. + /// Single-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat2x2, aligned_f32mat2x2, 16); - /// Single-precision floating-point aligned 2x3 matrix. + /// Single-qualifier floating-point aligned 2x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat2x3, aligned_f32mat2x3, 16); - /// Single-precision floating-point aligned 2x4 matrix. + /// Single-qualifier floating-point aligned 2x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat2x4, aligned_f32mat2x4, 16); - /// Single-precision floating-point aligned 3x2 matrix. + /// Single-qualifier floating-point aligned 3x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat3x2, aligned_f32mat3x2, 16); - /// Single-precision floating-point aligned 3x3 matrix. + /// Single-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat3x3, aligned_f32mat3x3, 16); - /// Single-precision floating-point aligned 3x4 matrix. + /// Single-qualifier floating-point aligned 3x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat3x4, aligned_f32mat3x4, 16); - /// Single-precision floating-point aligned 4x2 matrix. + /// Single-qualifier floating-point aligned 4x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat4x2, aligned_f32mat4x2, 16); - /// Single-precision floating-point aligned 4x3 matrix. + /// Single-qualifier floating-point aligned 4x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat4x3, aligned_f32mat4x3, 16); - /// Single-precision floating-point aligned 4x4 matrix. + /// Single-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32mat4x4, aligned_f32mat4x4, 16); - /// Double-precision floating-point aligned 1x1 matrix. + /// Double-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef detail::tmat1x1 f64mat1; - /// Double-precision floating-point aligned 2x2 matrix. + /// Double-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat2x2, aligned_f64mat2, 32); - /// Double-precision floating-point aligned 3x3 matrix. + /// Double-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat3x3, aligned_f64mat3, 32); - /// Double-precision floating-point aligned 4x4 matrix. + /// Double-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat4x4, aligned_f64mat4, 32); - /// Double-precision floating-point aligned 1x1 matrix. + /// Double-qualifier floating-point aligned 1x1 matrix. /// @see gtx_type_aligned //typedef f64 f64mat1x1; - /// Double-precision floating-point aligned 2x2 matrix. + /// Double-qualifier floating-point aligned 2x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat2x2, aligned_f64mat2x2, 32); - /// Double-precision floating-point aligned 2x3 matrix. + /// Double-qualifier floating-point aligned 2x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat2x3, aligned_f64mat2x3, 32); - /// Double-precision floating-point aligned 2x4 matrix. + /// Double-qualifier floating-point aligned 2x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat2x4, aligned_f64mat2x4, 32); - /// Double-precision floating-point aligned 3x2 matrix. + /// Double-qualifier floating-point aligned 3x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat3x2, aligned_f64mat3x2, 32); - /// Double-precision floating-point aligned 3x3 matrix. + /// Double-qualifier floating-point aligned 3x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat3x3, aligned_f64mat3x3, 32); - /// Double-precision floating-point aligned 3x4 matrix. + /// Double-qualifier floating-point aligned 3x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat3x4, aligned_f64mat3x4, 32); - /// Double-precision floating-point aligned 4x2 matrix. + /// Double-qualifier floating-point aligned 4x2 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat4x2, aligned_f64mat4x2, 32); - /// Double-precision floating-point aligned 4x3 matrix. + /// Double-qualifier floating-point aligned 4x3 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat4x3, aligned_f64mat4x3, 32); - /// Double-precision floating-point aligned 4x4 matrix. + /// Double-qualifier floating-point aligned 4x4 matrix. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64mat4x4, aligned_f64mat4x4, 32); @@ -944,23 +944,23 @@ namespace glm ////////////////////////// // Quaternion types - /// Single-precision floating-point aligned quaternion. + /// Single-qualifier floating-point aligned quaternion. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(quat, aligned_quat, 16); - /// Single-precision floating-point aligned quaternion. + /// Single-qualifier floating-point aligned quaternion. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(fquat, aligned_fquat, 16); - /// Double-precision floating-point aligned quaternion. + /// Double-qualifier floating-point aligned quaternion. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(dquat, aligned_dquat, 32); - /// Single-precision floating-point aligned quaternion. + /// Single-qualifier floating-point aligned quaternion. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f32quat, aligned_f32quat, 16); - /// Double-precision floating-point aligned quaternion. + /// Double-qualifier floating-point aligned quaternion. /// @see gtx_type_aligned GLM_ALIGNED_TYPEDEF(f64quat, aligned_f64quat, 32); diff --git a/glm/gtx/type_trait.hpp b/glm/gtx/type_trait.hpp index 4f0ba9b9..0433dfb1 100644 --- a/glm/gtx/type_trait.hpp +++ b/glm/gtx/type_trait.hpp @@ -52,7 +52,7 @@ namespace glm static length_t const rows = 0; }; - template + template struct type > { static bool const is_vec = true; @@ -64,7 +64,7 @@ namespace glm }; }; - template + template struct type > { static bool const is_vec = false; @@ -78,7 +78,7 @@ namespace glm }; }; - template + template struct type > { static bool const is_vec = false; @@ -92,7 +92,7 @@ namespace glm }; }; - template + template struct type > { static bool const is_vec = false; @@ -106,7 +106,7 @@ namespace glm }; }; - template + template struct type > { static bool const is_vec = false; @@ -120,7 +120,7 @@ namespace glm }; }; - template + template struct type > { static bool const is_vec = false; @@ -134,7 +134,7 @@ namespace glm }; }; - template + template struct type > { static bool const is_vec = false; @@ -148,7 +148,7 @@ namespace glm }; }; - template + template struct type > { static bool const is_vec = false; @@ -162,7 +162,7 @@ namespace glm }; }; - template + template struct type > { static bool const is_vec = false; @@ -176,7 +176,7 @@ namespace glm }; }; - template + template struct type > { static bool const is_vec = false; @@ -190,7 +190,7 @@ namespace glm }; }; - template + template struct type > { static bool const is_vec = false; @@ -202,7 +202,7 @@ namespace glm }; }; - template + template struct type > { static bool const is_vec = false; diff --git a/glm/gtx/vec_swizzle.hpp b/glm/gtx/vec_swizzle.hpp index c325d30c..f5f17aab 100644 --- a/glm/gtx/vec_swizzle.hpp +++ b/glm/gtx/vec_swizzle.hpp @@ -20,2757 +20,2757 @@ namespace glm { // xx - template + template GLM_INLINE glm::vec<2, T, P> xx(const glm::vec<1, T, P> &v) { return glm::vec<2, T, P>(v.x, v.x); } - template + template GLM_INLINE glm::vec<2, T, P> xx(const glm::vec<2, T, P> &v) { return glm::vec<2, T, P>(v.x, v.x); } - template + template GLM_INLINE glm::vec<2, T, P> xx(const glm::vec<3, T, P> &v) { return glm::vec<2, T, P>(v.x, v.x); } - template + template GLM_INLINE glm::vec<2, T, P> xx(const glm::vec<4, T, P> &v) { return glm::vec<2, T, P>(v.x, v.x); } // xy - template + template GLM_INLINE glm::vec<2, T, P> xy(const glm::vec<2, T, P> &v) { return glm::vec<2, T, P>(v.x, v.y); } - template + template GLM_INLINE glm::vec<2, T, P> xy(const glm::vec<3, T, P> &v) { return glm::vec<2, T, P>(v.x, v.y); } - template + template GLM_INLINE glm::vec<2, T, P> xy(const glm::vec<4, T, P> &v) { return glm::vec<2, T, P>(v.x, v.y); } // xz - template + template GLM_INLINE glm::vec<2, T, P> xz(const glm::vec<3, T, P> &v) { return glm::vec<2, T, P>(v.x, v.z); } - template + template GLM_INLINE glm::vec<2, T, P> xz(const glm::vec<4, T, P> &v) { return glm::vec<2, T, P>(v.x, v.z); } // xw - template + template GLM_INLINE glm::vec<2, T, P> xw(const glm::vec<4, T, P> &v) { return glm::vec<2, T, P>(v.x, v.w); } // yx - template + template GLM_INLINE glm::vec<2, T, P> yx(const glm::vec<2, T, P> &v) { return glm::vec<2, T, P>(v.y, v.x); } - template + template GLM_INLINE glm::vec<2, T, P> yx(const glm::vec<3, T, P> &v) { return glm::vec<2, T, P>(v.y, v.x); } - template + template GLM_INLINE glm::vec<2, T, P> yx(const glm::vec<4, T, P> &v) { return glm::vec<2, T, P>(v.y, v.x); } // yy - template + template GLM_INLINE glm::vec<2, T, P> yy(const glm::vec<2, T, P> &v) { return glm::vec<2, T, P>(v.y, v.y); } - template + template GLM_INLINE glm::vec<2, T, P> yy(const glm::vec<3, T, P> &v) { return glm::vec<2, T, P>(v.y, v.y); } - template + template GLM_INLINE glm::vec<2, T, P> yy(const glm::vec<4, T, P> &v) { return glm::vec<2, T, P>(v.y, v.y); } // yz - template + template GLM_INLINE glm::vec<2, T, P> yz(const glm::vec<3, T, P> &v) { return glm::vec<2, T, P>(v.y, v.z); } - template + template GLM_INLINE glm::vec<2, T, P> yz(const glm::vec<4, T, P> &v) { return glm::vec<2, T, P>(v.y, v.z); } // yw - template + template GLM_INLINE glm::vec<2, T, P> yw(const glm::vec<4, T, P> &v) { return glm::vec<2, T, P>(v.y, v.w); } // zx - template + template GLM_INLINE glm::vec<2, T, P> zx(const glm::vec<3, T, P> &v) { return glm::vec<2, T, P>(v.z, v.x); } - template + template GLM_INLINE glm::vec<2, T, P> zx(const glm::vec<4, T, P> &v) { return glm::vec<2, T, P>(v.z, v.x); } // zy - template + template GLM_INLINE glm::vec<2, T, P> zy(const glm::vec<3, T, P> &v) { return glm::vec<2, T, P>(v.z, v.y); } - template + template GLM_INLINE glm::vec<2, T, P> zy(const glm::vec<4, T, P> &v) { return glm::vec<2, T, P>(v.z, v.y); } // zz - template + template GLM_INLINE glm::vec<2, T, P> zz(const glm::vec<3, T, P> &v) { return glm::vec<2, T, P>(v.z, v.z); } - template + template GLM_INLINE glm::vec<2, T, P> zz(const glm::vec<4, T, P> &v) { return glm::vec<2, T, P>(v.z, v.z); } // zw - template + template GLM_INLINE glm::vec<2, T, P> zw(const glm::vec<4, T, P> &v) { return glm::vec<2, T, P>(v.z, v.w); } // wx - template + template GLM_INLINE glm::vec<2, T, P> wx(const glm::vec<4, T, P> &v) { return glm::vec<2, T, P>(v.w, v.x); } // wy - template + template GLM_INLINE glm::vec<2, T, P> wy(const glm::vec<4, T, P> &v) { return glm::vec<2, T, P>(v.w, v.y); } // wz - template + template GLM_INLINE glm::vec<2, T, P> wz(const glm::vec<4, T, P> &v) { return glm::vec<2, T, P>(v.w, v.z); } // ww - template + template GLM_INLINE glm::vec<2, T, P> ww(const glm::vec<4, T, P> &v) { return glm::vec<2, T, P>(v.w, v.w); } // xxx - template + template GLM_INLINE glm::vec<3, T, P> xxx(const glm::vec<1, T, P> &v) { return glm::vec<3, T, P>(v.x, v.x, v.x); } - template + template GLM_INLINE glm::vec<3, T, P> xxx(const glm::vec<2, T, P> &v) { return glm::vec<3, T, P>(v.x, v.x, v.x); } - template + template GLM_INLINE glm::vec<3, T, P> xxx(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.x, v.x, v.x); } - template + template GLM_INLINE glm::vec<3, T, P> xxx(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.x, v.x, v.x); } // xxy - template + template GLM_INLINE glm::vec<3, T, P> xxy(const glm::vec<2, T, P> &v) { return glm::vec<3, T, P>(v.x, v.x, v.y); } - template + template GLM_INLINE glm::vec<3, T, P> xxy(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.x, v.x, v.y); } - template + template GLM_INLINE glm::vec<3, T, P> xxy(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.x, v.x, v.y); } // xxz - template + template GLM_INLINE glm::vec<3, T, P> xxz(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.x, v.x, v.z); } - template + template GLM_INLINE glm::vec<3, T, P> xxz(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.x, v.x, v.z); } // xxw - template + template GLM_INLINE glm::vec<3, T, P> xxw(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.x, v.x, v.w); } // xyx - template + template GLM_INLINE glm::vec<3, T, P> xyx(const glm::vec<2, T, P> &v) { return glm::vec<3, T, P>(v.x, v.y, v.x); } - template + template GLM_INLINE glm::vec<3, T, P> xyx(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.x, v.y, v.x); } - template + template GLM_INLINE glm::vec<3, T, P> xyx(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.x, v.y, v.x); } // xyy - template + template GLM_INLINE glm::vec<3, T, P> xyy(const glm::vec<2, T, P> &v) { return glm::vec<3, T, P>(v.x, v.y, v.y); } - template + template GLM_INLINE glm::vec<3, T, P> xyy(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.x, v.y, v.y); } - template + template GLM_INLINE glm::vec<3, T, P> xyy(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.x, v.y, v.y); } // xyz - template + template GLM_INLINE glm::vec<3, T, P> xyz(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.x, v.y, v.z); } - template + template GLM_INLINE glm::vec<3, T, P> xyz(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.x, v.y, v.z); } // xyw - template + template GLM_INLINE glm::vec<3, T, P> xyw(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.x, v.y, v.w); } // xzx - template + template GLM_INLINE glm::vec<3, T, P> xzx(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.x, v.z, v.x); } - template + template GLM_INLINE glm::vec<3, T, P> xzx(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.x, v.z, v.x); } // xzy - template + template GLM_INLINE glm::vec<3, T, P> xzy(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.x, v.z, v.y); } - template + template GLM_INLINE glm::vec<3, T, P> xzy(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.x, v.z, v.y); } // xzz - template + template GLM_INLINE glm::vec<3, T, P> xzz(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.x, v.z, v.z); } - template + template GLM_INLINE glm::vec<3, T, P> xzz(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.x, v.z, v.z); } // xzw - template + template GLM_INLINE glm::vec<3, T, P> xzw(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.x, v.z, v.w); } // xwx - template + template GLM_INLINE glm::vec<3, T, P> xwx(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.x, v.w, v.x); } // xwy - template + template GLM_INLINE glm::vec<3, T, P> xwy(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.x, v.w, v.y); } // xwz - template + template GLM_INLINE glm::vec<3, T, P> xwz(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.x, v.w, v.z); } // xww - template + template GLM_INLINE glm::vec<3, T, P> xww(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.x, v.w, v.w); } // yxx - template + template GLM_INLINE glm::vec<3, T, P> yxx(const glm::vec<2, T, P> &v) { return glm::vec<3, T, P>(v.y, v.x, v.x); } - template + template GLM_INLINE glm::vec<3, T, P> yxx(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.y, v.x, v.x); } - template + template GLM_INLINE glm::vec<3, T, P> yxx(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.y, v.x, v.x); } // yxy - template + template GLM_INLINE glm::vec<3, T, P> yxy(const glm::vec<2, T, P> &v) { return glm::vec<3, T, P>(v.y, v.x, v.y); } - template + template GLM_INLINE glm::vec<3, T, P> yxy(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.y, v.x, v.y); } - template + template GLM_INLINE glm::vec<3, T, P> yxy(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.y, v.x, v.y); } // yxz - template + template GLM_INLINE glm::vec<3, T, P> yxz(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.y, v.x, v.z); } - template + template GLM_INLINE glm::vec<3, T, P> yxz(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.y, v.x, v.z); } // yxw - template + template GLM_INLINE glm::vec<3, T, P> yxw(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.y, v.x, v.w); } // yyx - template + template GLM_INLINE glm::vec<3, T, P> yyx(const glm::vec<2, T, P> &v) { return glm::vec<3, T, P>(v.y, v.y, v.x); } - template + template GLM_INLINE glm::vec<3, T, P> yyx(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.y, v.y, v.x); } - template + template GLM_INLINE glm::vec<3, T, P> yyx(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.y, v.y, v.x); } // yyy - template + template GLM_INLINE glm::vec<3, T, P> yyy(const glm::vec<2, T, P> &v) { return glm::vec<3, T, P>(v.y, v.y, v.y); } - template + template GLM_INLINE glm::vec<3, T, P> yyy(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.y, v.y, v.y); } - template + template GLM_INLINE glm::vec<3, T, P> yyy(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.y, v.y, v.y); } // yyz - template + template GLM_INLINE glm::vec<3, T, P> yyz(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.y, v.y, v.z); } - template + template GLM_INLINE glm::vec<3, T, P> yyz(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.y, v.y, v.z); } // yyw - template + template GLM_INLINE glm::vec<3, T, P> yyw(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.y, v.y, v.w); } // yzx - template + template GLM_INLINE glm::vec<3, T, P> yzx(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.y, v.z, v.x); } - template + template GLM_INLINE glm::vec<3, T, P> yzx(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.y, v.z, v.x); } // yzy - template + template GLM_INLINE glm::vec<3, T, P> yzy(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.y, v.z, v.y); } - template + template GLM_INLINE glm::vec<3, T, P> yzy(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.y, v.z, v.y); } // yzz - template + template GLM_INLINE glm::vec<3, T, P> yzz(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.y, v.z, v.z); } - template + template GLM_INLINE glm::vec<3, T, P> yzz(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.y, v.z, v.z); } // yzw - template + template GLM_INLINE glm::vec<3, T, P> yzw(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.y, v.z, v.w); } // ywx - template + template GLM_INLINE glm::vec<3, T, P> ywx(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.y, v.w, v.x); } // ywy - template + template GLM_INLINE glm::vec<3, T, P> ywy(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.y, v.w, v.y); } // ywz - template + template GLM_INLINE glm::vec<3, T, P> ywz(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.y, v.w, v.z); } // yww - template + template GLM_INLINE glm::vec<3, T, P> yww(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.y, v.w, v.w); } // zxx - template + template GLM_INLINE glm::vec<3, T, P> zxx(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.z, v.x, v.x); } - template + template GLM_INLINE glm::vec<3, T, P> zxx(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.z, v.x, v.x); } // zxy - template + template GLM_INLINE glm::vec<3, T, P> zxy(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.z, v.x, v.y); } - template + template GLM_INLINE glm::vec<3, T, P> zxy(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.z, v.x, v.y); } // zxz - template + template GLM_INLINE glm::vec<3, T, P> zxz(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.z, v.x, v.z); } - template + template GLM_INLINE glm::vec<3, T, P> zxz(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.z, v.x, v.z); } // zxw - template + template GLM_INLINE glm::vec<3, T, P> zxw(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.z, v.x, v.w); } // zyx - template + template GLM_INLINE glm::vec<3, T, P> zyx(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.z, v.y, v.x); } - template + template GLM_INLINE glm::vec<3, T, P> zyx(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.z, v.y, v.x); } // zyy - template + template GLM_INLINE glm::vec<3, T, P> zyy(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.z, v.y, v.y); } - template + template GLM_INLINE glm::vec<3, T, P> zyy(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.z, v.y, v.y); } // zyz - template + template GLM_INLINE glm::vec<3, T, P> zyz(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.z, v.y, v.z); } - template + template GLM_INLINE glm::vec<3, T, P> zyz(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.z, v.y, v.z); } // zyw - template + template GLM_INLINE glm::vec<3, T, P> zyw(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.z, v.y, v.w); } // zzx - template + template GLM_INLINE glm::vec<3, T, P> zzx(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.z, v.z, v.x); } - template + template GLM_INLINE glm::vec<3, T, P> zzx(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.z, v.z, v.x); } // zzy - template + template GLM_INLINE glm::vec<3, T, P> zzy(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.z, v.z, v.y); } - template + template GLM_INLINE glm::vec<3, T, P> zzy(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.z, v.z, v.y); } // zzz - template + template GLM_INLINE glm::vec<3, T, P> zzz(const glm::vec<3, T, P> &v) { return glm::vec<3, T, P>(v.z, v.z, v.z); } - template + template GLM_INLINE glm::vec<3, T, P> zzz(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.z, v.z, v.z); } // zzw - template + template GLM_INLINE glm::vec<3, T, P> zzw(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.z, v.z, v.w); } // zwx - template + template GLM_INLINE glm::vec<3, T, P> zwx(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.z, v.w, v.x); } // zwy - template + template GLM_INLINE glm::vec<3, T, P> zwy(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.z, v.w, v.y); } // zwz - template + template GLM_INLINE glm::vec<3, T, P> zwz(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.z, v.w, v.z); } // zww - template + template GLM_INLINE glm::vec<3, T, P> zww(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.z, v.w, v.w); } // wxx - template + template GLM_INLINE glm::vec<3, T, P> wxx(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.w, v.x, v.x); } // wxy - template + template GLM_INLINE glm::vec<3, T, P> wxy(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.w, v.x, v.y); } // wxz - template + template GLM_INLINE glm::vec<3, T, P> wxz(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.w, v.x, v.z); } // wxw - template + template GLM_INLINE glm::vec<3, T, P> wxw(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.w, v.x, v.w); } // wyx - template + template GLM_INLINE glm::vec<3, T, P> wyx(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.w, v.y, v.x); } // wyy - template + template GLM_INLINE glm::vec<3, T, P> wyy(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.w, v.y, v.y); } // wyz - template + template GLM_INLINE glm::vec<3, T, P> wyz(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.w, v.y, v.z); } // wyw - template + template GLM_INLINE glm::vec<3, T, P> wyw(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.w, v.y, v.w); } // wzx - template + template GLM_INLINE glm::vec<3, T, P> wzx(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.w, v.z, v.x); } // wzy - template + template GLM_INLINE glm::vec<3, T, P> wzy(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.w, v.z, v.y); } // wzz - template + template GLM_INLINE glm::vec<3, T, P> wzz(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.w, v.z, v.z); } // wzw - template + template GLM_INLINE glm::vec<3, T, P> wzw(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.w, v.z, v.w); } // wwx - template + template GLM_INLINE glm::vec<3, T, P> wwx(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.w, v.w, v.x); } // wwy - template + template GLM_INLINE glm::vec<3, T, P> wwy(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.w, v.w, v.y); } // wwz - template + template GLM_INLINE glm::vec<3, T, P> wwz(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.w, v.w, v.z); } // www - template + template GLM_INLINE glm::vec<3, T, P> www(const glm::vec<4, T, P> &v) { return glm::vec<3, T, P>(v.w, v.w, v.w); } // xxxx - template + template GLM_INLINE glm::vec<4, T, P> xxxx(const glm::vec<1, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.x, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> xxxx(const glm::vec<2, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.x, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> xxxx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.x, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> xxxx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.x, v.x); } // xxxy - template + template GLM_INLINE glm::vec<4, T, P> xxxy(const glm::vec<2, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.x, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> xxxy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.x, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> xxxy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.x, v.y); } // xxxz - template + template GLM_INLINE glm::vec<4, T, P> xxxz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.x, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> xxxz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.x, v.z); } // xxxw - template + template GLM_INLINE glm::vec<4, T, P> xxxw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.x, v.w); } // xxyx - template + template GLM_INLINE glm::vec<4, T, P> xxyx(const glm::vec<2, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.y, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> xxyx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.y, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> xxyx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.y, v.x); } // xxyy - template + template GLM_INLINE glm::vec<4, T, P> xxyy(const glm::vec<2, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.y, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> xxyy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.y, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> xxyy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.y, v.y); } // xxyz - template + template GLM_INLINE glm::vec<4, T, P> xxyz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.y, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> xxyz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.y, v.z); } // xxyw - template + template GLM_INLINE glm::vec<4, T, P> xxyw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.y, v.w); } // xxzx - template + template GLM_INLINE glm::vec<4, T, P> xxzx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.z, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> xxzx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.z, v.x); } // xxzy - template + template GLM_INLINE glm::vec<4, T, P> xxzy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.z, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> xxzy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.z, v.y); } // xxzz - template + template GLM_INLINE glm::vec<4, T, P> xxzz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.z, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> xxzz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.z, v.z); } // xxzw - template + template GLM_INLINE glm::vec<4, T, P> xxzw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.z, v.w); } // xxwx - template + template GLM_INLINE glm::vec<4, T, P> xxwx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.w, v.x); } // xxwy - template + template GLM_INLINE glm::vec<4, T, P> xxwy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.w, v.y); } // xxwz - template + template GLM_INLINE glm::vec<4, T, P> xxwz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.w, v.z); } // xxww - template + template GLM_INLINE glm::vec<4, T, P> xxww(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.x, v.w, v.w); } // xyxx - template + template GLM_INLINE glm::vec<4, T, P> xyxx(const glm::vec<2, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.x, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> xyxx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.x, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> xyxx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.x, v.x); } // xyxy - template + template GLM_INLINE glm::vec<4, T, P> xyxy(const glm::vec<2, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.x, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> xyxy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.x, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> xyxy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.x, v.y); } // xyxz - template + template GLM_INLINE glm::vec<4, T, P> xyxz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.x, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> xyxz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.x, v.z); } // xyxw - template + template GLM_INLINE glm::vec<4, T, P> xyxw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.x, v.w); } // xyyx - template + template GLM_INLINE glm::vec<4, T, P> xyyx(const glm::vec<2, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.y, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> xyyx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.y, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> xyyx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.y, v.x); } // xyyy - template + template GLM_INLINE glm::vec<4, T, P> xyyy(const glm::vec<2, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.y, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> xyyy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.y, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> xyyy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.y, v.y); } // xyyz - template + template GLM_INLINE glm::vec<4, T, P> xyyz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.y, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> xyyz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.y, v.z); } // xyyw - template + template GLM_INLINE glm::vec<4, T, P> xyyw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.y, v.w); } // xyzx - template + template GLM_INLINE glm::vec<4, T, P> xyzx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.z, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> xyzx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.z, v.x); } // xyzy - template + template GLM_INLINE glm::vec<4, T, P> xyzy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.z, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> xyzy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.z, v.y); } // xyzz - template + template GLM_INLINE glm::vec<4, T, P> xyzz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.z, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> xyzz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.z, v.z); } // xyzw - template + template GLM_INLINE glm::vec<4, T, P> xyzw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.z, v.w); } // xywx - template + template GLM_INLINE glm::vec<4, T, P> xywx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.w, v.x); } // xywy - template + template GLM_INLINE glm::vec<4, T, P> xywy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.w, v.y); } // xywz - template + template GLM_INLINE glm::vec<4, T, P> xywz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.w, v.z); } // xyww - template + template GLM_INLINE glm::vec<4, T, P> xyww(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.y, v.w, v.w); } // xzxx - template + template GLM_INLINE glm::vec<4, T, P> xzxx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.x, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> xzxx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.x, v.x); } // xzxy - template + template GLM_INLINE glm::vec<4, T, P> xzxy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.x, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> xzxy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.x, v.y); } // xzxz - template + template GLM_INLINE glm::vec<4, T, P> xzxz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.x, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> xzxz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.x, v.z); } // xzxw - template + template GLM_INLINE glm::vec<4, T, P> xzxw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.x, v.w); } // xzyx - template + template GLM_INLINE glm::vec<4, T, P> xzyx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.y, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> xzyx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.y, v.x); } // xzyy - template + template GLM_INLINE glm::vec<4, T, P> xzyy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.y, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> xzyy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.y, v.y); } // xzyz - template + template GLM_INLINE glm::vec<4, T, P> xzyz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.y, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> xzyz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.y, v.z); } // xzyw - template + template GLM_INLINE glm::vec<4, T, P> xzyw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.y, v.w); } // xzzx - template + template GLM_INLINE glm::vec<4, T, P> xzzx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.z, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> xzzx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.z, v.x); } // xzzy - template + template GLM_INLINE glm::vec<4, T, P> xzzy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.z, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> xzzy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.z, v.y); } // xzzz - template + template GLM_INLINE glm::vec<4, T, P> xzzz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.z, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> xzzz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.z, v.z); } // xzzw - template + template GLM_INLINE glm::vec<4, T, P> xzzw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.z, v.w); } // xzwx - template + template GLM_INLINE glm::vec<4, T, P> xzwx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.w, v.x); } // xzwy - template + template GLM_INLINE glm::vec<4, T, P> xzwy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.w, v.y); } // xzwz - template + template GLM_INLINE glm::vec<4, T, P> xzwz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.w, v.z); } // xzww - template + template GLM_INLINE glm::vec<4, T, P> xzww(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.z, v.w, v.w); } // xwxx - template + template GLM_INLINE glm::vec<4, T, P> xwxx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.w, v.x, v.x); } // xwxy - template + template GLM_INLINE glm::vec<4, T, P> xwxy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.w, v.x, v.y); } // xwxz - template + template GLM_INLINE glm::vec<4, T, P> xwxz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.w, v.x, v.z); } // xwxw - template + template GLM_INLINE glm::vec<4, T, P> xwxw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.w, v.x, v.w); } // xwyx - template + template GLM_INLINE glm::vec<4, T, P> xwyx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.w, v.y, v.x); } // xwyy - template + template GLM_INLINE glm::vec<4, T, P> xwyy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.w, v.y, v.y); } // xwyz - template + template GLM_INLINE glm::vec<4, T, P> xwyz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.w, v.y, v.z); } // xwyw - template + template GLM_INLINE glm::vec<4, T, P> xwyw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.w, v.y, v.w); } // xwzx - template + template GLM_INLINE glm::vec<4, T, P> xwzx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.w, v.z, v.x); } // xwzy - template + template GLM_INLINE glm::vec<4, T, P> xwzy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.w, v.z, v.y); } // xwzz - template + template GLM_INLINE glm::vec<4, T, P> xwzz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.w, v.z, v.z); } // xwzw - template + template GLM_INLINE glm::vec<4, T, P> xwzw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.w, v.z, v.w); } // xwwx - template + template GLM_INLINE glm::vec<4, T, P> xwwx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.w, v.w, v.x); } // xwwy - template + template GLM_INLINE glm::vec<4, T, P> xwwy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.w, v.w, v.y); } // xwwz - template + template GLM_INLINE glm::vec<4, T, P> xwwz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.w, v.w, v.z); } // xwww - template + template GLM_INLINE glm::vec<4, T, P> xwww(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.x, v.w, v.w, v.w); } // yxxx - template + template GLM_INLINE glm::vec<4, T, P> yxxx(const glm::vec<2, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.x, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> yxxx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.x, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> yxxx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.x, v.x); } // yxxy - template + template GLM_INLINE glm::vec<4, T, P> yxxy(const glm::vec<2, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.x, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> yxxy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.x, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> yxxy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.x, v.y); } // yxxz - template + template GLM_INLINE glm::vec<4, T, P> yxxz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.x, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> yxxz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.x, v.z); } // yxxw - template + template GLM_INLINE glm::vec<4, T, P> yxxw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.x, v.w); } // yxyx - template + template GLM_INLINE glm::vec<4, T, P> yxyx(const glm::vec<2, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.y, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> yxyx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.y, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> yxyx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.y, v.x); } // yxyy - template + template GLM_INLINE glm::vec<4, T, P> yxyy(const glm::vec<2, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.y, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> yxyy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.y, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> yxyy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.y, v.y); } // yxyz - template + template GLM_INLINE glm::vec<4, T, P> yxyz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.y, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> yxyz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.y, v.z); } // yxyw - template + template GLM_INLINE glm::vec<4, T, P> yxyw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.y, v.w); } // yxzx - template + template GLM_INLINE glm::vec<4, T, P> yxzx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.z, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> yxzx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.z, v.x); } // yxzy - template + template GLM_INLINE glm::vec<4, T, P> yxzy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.z, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> yxzy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.z, v.y); } // yxzz - template + template GLM_INLINE glm::vec<4, T, P> yxzz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.z, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> yxzz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.z, v.z); } // yxzw - template + template GLM_INLINE glm::vec<4, T, P> yxzw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.z, v.w); } // yxwx - template + template GLM_INLINE glm::vec<4, T, P> yxwx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.w, v.x); } // yxwy - template + template GLM_INLINE glm::vec<4, T, P> yxwy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.w, v.y); } // yxwz - template + template GLM_INLINE glm::vec<4, T, P> yxwz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.w, v.z); } // yxww - template + template GLM_INLINE glm::vec<4, T, P> yxww(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.x, v.w, v.w); } // yyxx - template + template GLM_INLINE glm::vec<4, T, P> yyxx(const glm::vec<2, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.x, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> yyxx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.x, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> yyxx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.x, v.x); } // yyxy - template + template GLM_INLINE glm::vec<4, T, P> yyxy(const glm::vec<2, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.x, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> yyxy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.x, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> yyxy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.x, v.y); } // yyxz - template + template GLM_INLINE glm::vec<4, T, P> yyxz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.x, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> yyxz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.x, v.z); } // yyxw - template + template GLM_INLINE glm::vec<4, T, P> yyxw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.x, v.w); } // yyyx - template + template GLM_INLINE glm::vec<4, T, P> yyyx(const glm::vec<2, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.y, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> yyyx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.y, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> yyyx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.y, v.x); } // yyyy - template + template GLM_INLINE glm::vec<4, T, P> yyyy(const glm::vec<2, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.y, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> yyyy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.y, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> yyyy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.y, v.y); } // yyyz - template + template GLM_INLINE glm::vec<4, T, P> yyyz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.y, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> yyyz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.y, v.z); } // yyyw - template + template GLM_INLINE glm::vec<4, T, P> yyyw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.y, v.w); } // yyzx - template + template GLM_INLINE glm::vec<4, T, P> yyzx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.z, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> yyzx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.z, v.x); } // yyzy - template + template GLM_INLINE glm::vec<4, T, P> yyzy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.z, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> yyzy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.z, v.y); } // yyzz - template + template GLM_INLINE glm::vec<4, T, P> yyzz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.z, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> yyzz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.z, v.z); } // yyzw - template + template GLM_INLINE glm::vec<4, T, P> yyzw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.z, v.w); } // yywx - template + template GLM_INLINE glm::vec<4, T, P> yywx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.w, v.x); } // yywy - template + template GLM_INLINE glm::vec<4, T, P> yywy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.w, v.y); } // yywz - template + template GLM_INLINE glm::vec<4, T, P> yywz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.w, v.z); } // yyww - template + template GLM_INLINE glm::vec<4, T, P> yyww(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.y, v.w, v.w); } // yzxx - template + template GLM_INLINE glm::vec<4, T, P> yzxx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.x, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> yzxx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.x, v.x); } // yzxy - template + template GLM_INLINE glm::vec<4, T, P> yzxy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.x, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> yzxy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.x, v.y); } // yzxz - template + template GLM_INLINE glm::vec<4, T, P> yzxz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.x, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> yzxz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.x, v.z); } // yzxw - template + template GLM_INLINE glm::vec<4, T, P> yzxw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.x, v.w); } // yzyx - template + template GLM_INLINE glm::vec<4, T, P> yzyx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.y, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> yzyx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.y, v.x); } // yzyy - template + template GLM_INLINE glm::vec<4, T, P> yzyy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.y, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> yzyy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.y, v.y); } // yzyz - template + template GLM_INLINE glm::vec<4, T, P> yzyz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.y, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> yzyz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.y, v.z); } // yzyw - template + template GLM_INLINE glm::vec<4, T, P> yzyw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.y, v.w); } // yzzx - template + template GLM_INLINE glm::vec<4, T, P> yzzx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.z, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> yzzx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.z, v.x); } // yzzy - template + template GLM_INLINE glm::vec<4, T, P> yzzy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.z, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> yzzy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.z, v.y); } // yzzz - template + template GLM_INLINE glm::vec<4, T, P> yzzz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.z, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> yzzz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.z, v.z); } // yzzw - template + template GLM_INLINE glm::vec<4, T, P> yzzw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.z, v.w); } // yzwx - template + template GLM_INLINE glm::vec<4, T, P> yzwx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.w, v.x); } // yzwy - template + template GLM_INLINE glm::vec<4, T, P> yzwy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.w, v.y); } // yzwz - template + template GLM_INLINE glm::vec<4, T, P> yzwz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.w, v.z); } // yzww - template + template GLM_INLINE glm::vec<4, T, P> yzww(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.z, v.w, v.w); } // ywxx - template + template GLM_INLINE glm::vec<4, T, P> ywxx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.w, v.x, v.x); } // ywxy - template + template GLM_INLINE glm::vec<4, T, P> ywxy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.w, v.x, v.y); } // ywxz - template + template GLM_INLINE glm::vec<4, T, P> ywxz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.w, v.x, v.z); } // ywxw - template + template GLM_INLINE glm::vec<4, T, P> ywxw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.w, v.x, v.w); } // ywyx - template + template GLM_INLINE glm::vec<4, T, P> ywyx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.w, v.y, v.x); } // ywyy - template + template GLM_INLINE glm::vec<4, T, P> ywyy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.w, v.y, v.y); } // ywyz - template + template GLM_INLINE glm::vec<4, T, P> ywyz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.w, v.y, v.z); } // ywyw - template + template GLM_INLINE glm::vec<4, T, P> ywyw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.w, v.y, v.w); } // ywzx - template + template GLM_INLINE glm::vec<4, T, P> ywzx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.w, v.z, v.x); } // ywzy - template + template GLM_INLINE glm::vec<4, T, P> ywzy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.w, v.z, v.y); } // ywzz - template + template GLM_INLINE glm::vec<4, T, P> ywzz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.w, v.z, v.z); } // ywzw - template + template GLM_INLINE glm::vec<4, T, P> ywzw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.w, v.z, v.w); } // ywwx - template + template GLM_INLINE glm::vec<4, T, P> ywwx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.w, v.w, v.x); } // ywwy - template + template GLM_INLINE glm::vec<4, T, P> ywwy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.w, v.w, v.y); } // ywwz - template + template GLM_INLINE glm::vec<4, T, P> ywwz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.w, v.w, v.z); } // ywww - template + template GLM_INLINE glm::vec<4, T, P> ywww(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.y, v.w, v.w, v.w); } // zxxx - template + template GLM_INLINE glm::vec<4, T, P> zxxx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.x, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> zxxx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.x, v.x); } // zxxy - template + template GLM_INLINE glm::vec<4, T, P> zxxy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.x, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> zxxy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.x, v.y); } // zxxz - template + template GLM_INLINE glm::vec<4, T, P> zxxz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.x, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> zxxz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.x, v.z); } // zxxw - template + template GLM_INLINE glm::vec<4, T, P> zxxw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.x, v.w); } // zxyx - template + template GLM_INLINE glm::vec<4, T, P> zxyx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.y, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> zxyx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.y, v.x); } // zxyy - template + template GLM_INLINE glm::vec<4, T, P> zxyy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.y, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> zxyy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.y, v.y); } // zxyz - template + template GLM_INLINE glm::vec<4, T, P> zxyz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.y, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> zxyz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.y, v.z); } // zxyw - template + template GLM_INLINE glm::vec<4, T, P> zxyw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.y, v.w); } // zxzx - template + template GLM_INLINE glm::vec<4, T, P> zxzx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.z, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> zxzx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.z, v.x); } // zxzy - template + template GLM_INLINE glm::vec<4, T, P> zxzy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.z, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> zxzy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.z, v.y); } // zxzz - template + template GLM_INLINE glm::vec<4, T, P> zxzz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.z, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> zxzz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.z, v.z); } // zxzw - template + template GLM_INLINE glm::vec<4, T, P> zxzw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.z, v.w); } // zxwx - template + template GLM_INLINE glm::vec<4, T, P> zxwx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.w, v.x); } // zxwy - template + template GLM_INLINE glm::vec<4, T, P> zxwy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.w, v.y); } // zxwz - template + template GLM_INLINE glm::vec<4, T, P> zxwz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.w, v.z); } // zxww - template + template GLM_INLINE glm::vec<4, T, P> zxww(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.x, v.w, v.w); } // zyxx - template + template GLM_INLINE glm::vec<4, T, P> zyxx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.x, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> zyxx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.x, v.x); } // zyxy - template + template GLM_INLINE glm::vec<4, T, P> zyxy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.x, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> zyxy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.x, v.y); } // zyxz - template + template GLM_INLINE glm::vec<4, T, P> zyxz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.x, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> zyxz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.x, v.z); } // zyxw - template + template GLM_INLINE glm::vec<4, T, P> zyxw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.x, v.w); } // zyyx - template + template GLM_INLINE glm::vec<4, T, P> zyyx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.y, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> zyyx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.y, v.x); } // zyyy - template + template GLM_INLINE glm::vec<4, T, P> zyyy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.y, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> zyyy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.y, v.y); } // zyyz - template + template GLM_INLINE glm::vec<4, T, P> zyyz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.y, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> zyyz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.y, v.z); } // zyyw - template + template GLM_INLINE glm::vec<4, T, P> zyyw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.y, v.w); } // zyzx - template + template GLM_INLINE glm::vec<4, T, P> zyzx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.z, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> zyzx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.z, v.x); } // zyzy - template + template GLM_INLINE glm::vec<4, T, P> zyzy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.z, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> zyzy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.z, v.y); } // zyzz - template + template GLM_INLINE glm::vec<4, T, P> zyzz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.z, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> zyzz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.z, v.z); } // zyzw - template + template GLM_INLINE glm::vec<4, T, P> zyzw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.z, v.w); } // zywx - template + template GLM_INLINE glm::vec<4, T, P> zywx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.w, v.x); } // zywy - template + template GLM_INLINE glm::vec<4, T, P> zywy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.w, v.y); } // zywz - template + template GLM_INLINE glm::vec<4, T, P> zywz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.w, v.z); } // zyww - template + template GLM_INLINE glm::vec<4, T, P> zyww(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.y, v.w, v.w); } // zzxx - template + template GLM_INLINE glm::vec<4, T, P> zzxx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.x, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> zzxx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.x, v.x); } // zzxy - template + template GLM_INLINE glm::vec<4, T, P> zzxy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.x, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> zzxy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.x, v.y); } // zzxz - template + template GLM_INLINE glm::vec<4, T, P> zzxz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.x, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> zzxz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.x, v.z); } // zzxw - template + template GLM_INLINE glm::vec<4, T, P> zzxw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.x, v.w); } // zzyx - template + template GLM_INLINE glm::vec<4, T, P> zzyx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.y, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> zzyx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.y, v.x); } // zzyy - template + template GLM_INLINE glm::vec<4, T, P> zzyy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.y, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> zzyy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.y, v.y); } // zzyz - template + template GLM_INLINE glm::vec<4, T, P> zzyz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.y, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> zzyz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.y, v.z); } // zzyw - template + template GLM_INLINE glm::vec<4, T, P> zzyw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.y, v.w); } // zzzx - template + template GLM_INLINE glm::vec<4, T, P> zzzx(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.z, v.x); } - template + template GLM_INLINE glm::vec<4, T, P> zzzx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.z, v.x); } // zzzy - template + template GLM_INLINE glm::vec<4, T, P> zzzy(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.z, v.y); } - template + template GLM_INLINE glm::vec<4, T, P> zzzy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.z, v.y); } // zzzz - template + template GLM_INLINE glm::vec<4, T, P> zzzz(const glm::vec<3, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.z, v.z); } - template + template GLM_INLINE glm::vec<4, T, P> zzzz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.z, v.z); } // zzzw - template + template GLM_INLINE glm::vec<4, T, P> zzzw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.z, v.w); } // zzwx - template + template GLM_INLINE glm::vec<4, T, P> zzwx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.w, v.x); } // zzwy - template + template GLM_INLINE glm::vec<4, T, P> zzwy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.w, v.y); } // zzwz - template + template GLM_INLINE glm::vec<4, T, P> zzwz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.w, v.z); } // zzww - template + template GLM_INLINE glm::vec<4, T, P> zzww(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.z, v.w, v.w); } // zwxx - template + template GLM_INLINE glm::vec<4, T, P> zwxx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.w, v.x, v.x); } // zwxy - template + template GLM_INLINE glm::vec<4, T, P> zwxy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.w, v.x, v.y); } // zwxz - template + template GLM_INLINE glm::vec<4, T, P> zwxz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.w, v.x, v.z); } // zwxw - template + template GLM_INLINE glm::vec<4, T, P> zwxw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.w, v.x, v.w); } // zwyx - template + template GLM_INLINE glm::vec<4, T, P> zwyx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.w, v.y, v.x); } // zwyy - template + template GLM_INLINE glm::vec<4, T, P> zwyy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.w, v.y, v.y); } // zwyz - template + template GLM_INLINE glm::vec<4, T, P> zwyz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.w, v.y, v.z); } // zwyw - template + template GLM_INLINE glm::vec<4, T, P> zwyw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.w, v.y, v.w); } // zwzx - template + template GLM_INLINE glm::vec<4, T, P> zwzx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.w, v.z, v.x); } // zwzy - template + template GLM_INLINE glm::vec<4, T, P> zwzy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.w, v.z, v.y); } // zwzz - template + template GLM_INLINE glm::vec<4, T, P> zwzz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.w, v.z, v.z); } // zwzw - template + template GLM_INLINE glm::vec<4, T, P> zwzw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.w, v.z, v.w); } // zwwx - template + template GLM_INLINE glm::vec<4, T, P> zwwx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.w, v.w, v.x); } // zwwy - template + template GLM_INLINE glm::vec<4, T, P> zwwy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.w, v.w, v.y); } // zwwz - template + template GLM_INLINE glm::vec<4, T, P> zwwz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.w, v.w, v.z); } // zwww - template + template GLM_INLINE glm::vec<4, T, P> zwww(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.z, v.w, v.w, v.w); } // wxxx - template + template GLM_INLINE glm::vec<4, T, P> wxxx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.x, v.x, v.x); } // wxxy - template + template GLM_INLINE glm::vec<4, T, P> wxxy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.x, v.x, v.y); } // wxxz - template + template GLM_INLINE glm::vec<4, T, P> wxxz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.x, v.x, v.z); } // wxxw - template + template GLM_INLINE glm::vec<4, T, P> wxxw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.x, v.x, v.w); } // wxyx - template + template GLM_INLINE glm::vec<4, T, P> wxyx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.x, v.y, v.x); } // wxyy - template + template GLM_INLINE glm::vec<4, T, P> wxyy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.x, v.y, v.y); } // wxyz - template + template GLM_INLINE glm::vec<4, T, P> wxyz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.x, v.y, v.z); } // wxyw - template + template GLM_INLINE glm::vec<4, T, P> wxyw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.x, v.y, v.w); } // wxzx - template + template GLM_INLINE glm::vec<4, T, P> wxzx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.x, v.z, v.x); } // wxzy - template + template GLM_INLINE glm::vec<4, T, P> wxzy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.x, v.z, v.y); } // wxzz - template + template GLM_INLINE glm::vec<4, T, P> wxzz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.x, v.z, v.z); } // wxzw - template + template GLM_INLINE glm::vec<4, T, P> wxzw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.x, v.z, v.w); } // wxwx - template + template GLM_INLINE glm::vec<4, T, P> wxwx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.x, v.w, v.x); } // wxwy - template + template GLM_INLINE glm::vec<4, T, P> wxwy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.x, v.w, v.y); } // wxwz - template + template GLM_INLINE glm::vec<4, T, P> wxwz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.x, v.w, v.z); } // wxww - template + template GLM_INLINE glm::vec<4, T, P> wxww(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.x, v.w, v.w); } // wyxx - template + template GLM_INLINE glm::vec<4, T, P> wyxx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.y, v.x, v.x); } // wyxy - template + template GLM_INLINE glm::vec<4, T, P> wyxy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.y, v.x, v.y); } // wyxz - template + template GLM_INLINE glm::vec<4, T, P> wyxz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.y, v.x, v.z); } // wyxw - template + template GLM_INLINE glm::vec<4, T, P> wyxw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.y, v.x, v.w); } // wyyx - template + template GLM_INLINE glm::vec<4, T, P> wyyx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.y, v.y, v.x); } // wyyy - template + template GLM_INLINE glm::vec<4, T, P> wyyy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.y, v.y, v.y); } // wyyz - template + template GLM_INLINE glm::vec<4, T, P> wyyz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.y, v.y, v.z); } // wyyw - template + template GLM_INLINE glm::vec<4, T, P> wyyw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.y, v.y, v.w); } // wyzx - template + template GLM_INLINE glm::vec<4, T, P> wyzx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.y, v.z, v.x); } // wyzy - template + template GLM_INLINE glm::vec<4, T, P> wyzy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.y, v.z, v.y); } // wyzz - template + template GLM_INLINE glm::vec<4, T, P> wyzz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.y, v.z, v.z); } // wyzw - template + template GLM_INLINE glm::vec<4, T, P> wyzw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.y, v.z, v.w); } // wywx - template + template GLM_INLINE glm::vec<4, T, P> wywx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.y, v.w, v.x); } // wywy - template + template GLM_INLINE glm::vec<4, T, P> wywy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.y, v.w, v.y); } // wywz - template + template GLM_INLINE glm::vec<4, T, P> wywz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.y, v.w, v.z); } // wyww - template + template GLM_INLINE glm::vec<4, T, P> wyww(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.y, v.w, v.w); } // wzxx - template + template GLM_INLINE glm::vec<4, T, P> wzxx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.z, v.x, v.x); } // wzxy - template + template GLM_INLINE glm::vec<4, T, P> wzxy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.z, v.x, v.y); } // wzxz - template + template GLM_INLINE glm::vec<4, T, P> wzxz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.z, v.x, v.z); } // wzxw - template + template GLM_INLINE glm::vec<4, T, P> wzxw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.z, v.x, v.w); } // wzyx - template + template GLM_INLINE glm::vec<4, T, P> wzyx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.z, v.y, v.x); } // wzyy - template + template GLM_INLINE glm::vec<4, T, P> wzyy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.z, v.y, v.y); } // wzyz - template + template GLM_INLINE glm::vec<4, T, P> wzyz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.z, v.y, v.z); } // wzyw - template + template GLM_INLINE glm::vec<4, T, P> wzyw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.z, v.y, v.w); } // wzzx - template + template GLM_INLINE glm::vec<4, T, P> wzzx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.z, v.z, v.x); } // wzzy - template + template GLM_INLINE glm::vec<4, T, P> wzzy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.z, v.z, v.y); } // wzzz - template + template GLM_INLINE glm::vec<4, T, P> wzzz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.z, v.z, v.z); } // wzzw - template + template GLM_INLINE glm::vec<4, T, P> wzzw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.z, v.z, v.w); } // wzwx - template + template GLM_INLINE glm::vec<4, T, P> wzwx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.z, v.w, v.x); } // wzwy - template + template GLM_INLINE glm::vec<4, T, P> wzwy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.z, v.w, v.y); } // wzwz - template + template GLM_INLINE glm::vec<4, T, P> wzwz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.z, v.w, v.z); } // wzww - template + template GLM_INLINE glm::vec<4, T, P> wzww(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.z, v.w, v.w); } // wwxx - template + template GLM_INLINE glm::vec<4, T, P> wwxx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.w, v.x, v.x); } // wwxy - template + template GLM_INLINE glm::vec<4, T, P> wwxy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.w, v.x, v.y); } // wwxz - template + template GLM_INLINE glm::vec<4, T, P> wwxz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.w, v.x, v.z); } // wwxw - template + template GLM_INLINE glm::vec<4, T, P> wwxw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.w, v.x, v.w); } // wwyx - template + template GLM_INLINE glm::vec<4, T, P> wwyx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.w, v.y, v.x); } // wwyy - template + template GLM_INLINE glm::vec<4, T, P> wwyy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.w, v.y, v.y); } // wwyz - template + template GLM_INLINE glm::vec<4, T, P> wwyz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.w, v.y, v.z); } // wwyw - template + template GLM_INLINE glm::vec<4, T, P> wwyw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.w, v.y, v.w); } // wwzx - template + template GLM_INLINE glm::vec<4, T, P> wwzx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.w, v.z, v.x); } // wwzy - template + template GLM_INLINE glm::vec<4, T, P> wwzy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.w, v.z, v.y); } // wwzz - template + template GLM_INLINE glm::vec<4, T, P> wwzz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.w, v.z, v.z); } // wwzw - template + template GLM_INLINE glm::vec<4, T, P> wwzw(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.w, v.z, v.w); } // wwwx - template + template GLM_INLINE glm::vec<4, T, P> wwwx(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.w, v.w, v.x); } // wwwy - template + template GLM_INLINE glm::vec<4, T, P> wwwy(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.w, v.w, v.y); } // wwwz - template + template GLM_INLINE glm::vec<4, T, P> wwwz(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.w, v.w, v.z); } // wwww - template + template GLM_INLINE glm::vec<4, T, P> wwww(const glm::vec<4, T, P> &v) { return glm::vec<4, T, P>(v.w, v.w, v.w, v.w); } diff --git a/glm/gtx/vector_angle.hpp b/glm/gtx/vector_angle.hpp index 276da7e8..1ac93015 100644 --- a/glm/gtx/vector_angle.hpp +++ b/glm/gtx/vector_angle.hpp @@ -36,27 +36,20 @@ namespace glm //! Returns the absolute angle between two vectors. //! Parameters need to be normalized. /// @see gtx_vector_angle extension. - template - GLM_FUNC_DECL typename vecType::value_type angle( - vecType const & x, - vecType const & y); + template + GLM_FUNC_DECL T angle(vec const& x, vec const& y); //! Returns the oriented angle between two 2d vectors. //! Parameters need to be normalized. /// @see gtx_vector_angle extension. - template - GLM_FUNC_DECL T orientedAngle( - vec<2, T, P> const & x, - vec<2, T, P> const & y); + template + GLM_FUNC_DECL T orientedAngle(vec<2, T, P> const& x, vec<2, T, P> const& y); //! Returns the oriented angle between two 3d vectors based from a reference axis. //! Parameters need to be normalized. /// @see gtx_vector_angle extension. - template - GLM_FUNC_DECL T orientedAngle( - vec<3, T, P> const & x, - vec<3, T, P> const & y, - vec<3, T, P> const & ref); + template + GLM_FUNC_DECL T orientedAngle(vec<3, T, P> const& x, vec<3, T, P> const& y, vec<3, T, P> const& ref); /// @} }// namespace glm diff --git a/glm/gtx/vector_angle.inl b/glm/gtx/vector_angle.inl index af99344a..c2539aeb 100644 --- a/glm/gtx/vector_angle.inl +++ b/glm/gtx/vector_angle.inl @@ -14,24 +14,16 @@ namespace glm return acos(clamp(dot(x, y), genType(-1), genType(1))); } - template class vecType> - GLM_FUNC_QUALIFIER T angle - ( - vecType const& x, - vecType const& y - ) + template + GLM_FUNC_QUALIFIER T angle(vec const& x, vec const& y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'angle' only accept floating-point inputs"); return acos(clamp(dot(x, y), T(-1), T(1))); } //! \todo epsilon is hard coded to 0.01 - template - GLM_FUNC_QUALIFIER T orientedAngle - ( - vec<2, T, P> const & x, - vec<2, T, P> const & y - ) + template + GLM_FUNC_QUALIFIER T orientedAngle(vec<2, T, P> const & x, vec<2, T, P> const & y) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'orientedAngle' only accept floating-point inputs"); T const Angle(acos(clamp(dot(x, y), T(-1), T(1)))); @@ -42,13 +34,8 @@ namespace glm return -Angle; } - template - GLM_FUNC_QUALIFIER T orientedAngle - ( - vec<3, T, P> const & x, - vec<3, T, P> const & y, - vec<3, T, P> const & ref - ) + template + GLM_FUNC_QUALIFIER T orientedAngle(vec<3, T, P> const& x, vec<3, T, P> const& y, vec<3, T, P> const& ref) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'orientedAngle' only accept floating-point inputs"); diff --git a/glm/gtx/vector_query.hpp b/glm/gtx/vector_query.hpp index 80bbcea1..39422185 100644 --- a/glm/gtx/vector_query.hpp +++ b/glm/gtx/vector_query.hpp @@ -32,33 +32,33 @@ namespace glm //! Check whether two vectors are collinears. /// @see gtx_vector_query extensions. - template class vecType> - GLM_FUNC_DECL bool areCollinear(vecType const & v0, vecType const & v1, T const & epsilon); + template + GLM_FUNC_DECL bool areCollinear(vec const & v0, vec const & v1, T const & epsilon); //! Check whether two vectors are orthogonals. /// @see gtx_vector_query extensions. - template class vecType> - GLM_FUNC_DECL bool areOrthogonal(vecType const & v0, vecType const & v1, T const & epsilon); + template + GLM_FUNC_DECL bool areOrthogonal(vec const & v0, vec const & v1, T const & epsilon); //! Check whether a vector is normalized. /// @see gtx_vector_query extensions. - template class vecType> - GLM_FUNC_DECL bool isNormalized(vecType const & v, T const & epsilon); + template + GLM_FUNC_DECL bool isNormalized(vec const & v, T const & epsilon); //! Check whether a vector is null. /// @see gtx_vector_query extensions. - template class vecType> - GLM_FUNC_DECL bool isNull(vecType const & v, T const & epsilon); + template + GLM_FUNC_DECL bool isNull(vec const & v, T const & epsilon); //! Check whether a each component of a vector is null. /// @see gtx_vector_query extensions. - template class vecType> - GLM_FUNC_DECL vecType isCompNull(vecType const & v, T const & epsilon); + template + GLM_FUNC_DECL vec isCompNull(vec const & v, T const & epsilon); //! Check whether two vectors are orthonormal. /// @see gtx_vector_query extensions. - template class vecType> - GLM_FUNC_DECL bool areOrthonormal(vecType const & v0, vecType const & v1, T const & epsilon); + template + GLM_FUNC_DECL bool areOrthonormal(vec const & v0, vec const & v1, T const & epsilon); /// @} }// namespace glm diff --git a/glm/gtx/vector_query.inl b/glm/gtx/vector_query.inl index 6fa84db2..34ddfc32 100644 --- a/glm/gtx/vector_query.inl +++ b/glm/gtx/vector_query.inl @@ -6,11 +6,11 @@ namespace glm{ namespace detail { - template class vecType> + template struct compute_areCollinear{}; - template - struct compute_areCollinear<2, T, P, vec> + template + struct compute_areCollinear<2, T, P> { GLM_FUNC_QUALIFIER static bool call(vec<2, T, P> const & v0, vec<2, T, P> const & v1, T const & epsilon) { @@ -18,8 +18,8 @@ namespace detail } }; - template - struct compute_areCollinear<3, T, P, vec> + template + struct compute_areCollinear<3, T, P> { GLM_FUNC_QUALIFIER static bool call(vec<3, T, P> const & v0, vec<3, T, P> const & v1, T const & epsilon) { @@ -27,8 +27,8 @@ namespace detail } }; - template - struct compute_areCollinear<4, T, P, vec> + template + struct compute_areCollinear<4, T, P> { GLM_FUNC_QUALIFIER static bool call(vec<4, T, P> const & v0, vec<4, T, P> const & v1, T const & epsilon) { @@ -36,11 +36,11 @@ namespace detail } }; - template class vecType> + template struct compute_isCompNull{}; - template - struct compute_isCompNull<2, T, P, vec> + template + struct compute_isCompNull<2, T, P> { GLM_FUNC_QUALIFIER static vec<2, bool, P> call(vec<2, T, P> const & v, T const & epsilon) { @@ -50,8 +50,8 @@ namespace detail } }; - template - struct compute_isCompNull<3, T, P, vec> + template + struct compute_isCompNull<3, T, P> { GLM_FUNC_QUALIFIER static vec<3, bool, P> call(vec<3, T, P> const & v, T const & epsilon) { @@ -62,10 +62,10 @@ namespace detail } }; - template - struct compute_isCompNull<4, T, P, vec> + template + struct compute_isCompNull<4, T, P> { - GLM_FUNC_QUALIFIER static vec<4, bool, P> call(vec<4, T, P> const & v, T const & epsilon) + GLM_FUNC_QUALIFIER static vec<4, bool, P> call(vec<4, T, P> const & v, T const& epsilon) { return vec<4, bool, P>( (abs(v.x) < epsilon), @@ -77,26 +77,16 @@ namespace detail }//namespace detail - template class vecType> - GLM_FUNC_QUALIFIER bool areCollinear - ( - vecType const& v0, - vecType const& v1, - T const & epsilon - ) + template + GLM_FUNC_QUALIFIER bool areCollinear(vec const& v0, vec const& v1, T const& epsilon) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'areCollinear' only accept floating-point inputs"); - return detail::compute_areCollinear::call(v0, v1, epsilon); + return detail::compute_areCollinear::call(v0, v1, epsilon); } - template class vecType> - GLM_FUNC_QUALIFIER bool areOrthogonal - ( - vecType const& v0, - vecType const& v1, - T const & epsilon - ) + template + GLM_FUNC_QUALIFIER bool areOrthogonal(vec const& v0, vec const& v1, T const& epsilon) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'areOrthogonal' only accept floating-point inputs"); @@ -105,59 +95,40 @@ namespace detail length(v0)) * max(static_cast(1), length(v1)) * epsilon; } - template class vecType> - GLM_FUNC_QUALIFIER bool isNormalized - ( - vecType const& v, - T const & epsilon - ) + template + GLM_FUNC_QUALIFIER bool isNormalized(vec const& v, T const& epsilon) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isNormalized' only accept floating-point inputs"); return abs(length(v) - static_cast(1)) <= static_cast(2) * epsilon; } - template class vecType> - GLM_FUNC_QUALIFIER bool isNull - ( - vecType const& v, - T const & epsilon - ) + template + GLM_FUNC_QUALIFIER bool isNull(vec const& v, T const& epsilon) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isNull' only accept floating-point inputs"); return length(v) <= epsilon; } - template class vecType> - GLM_FUNC_QUALIFIER vecType isCompNull - ( - vecType const& v, - T const & epsilon - ) + template + GLM_FUNC_QUALIFIER vec isCompNull(vec const& v, T const& epsilon) { GLM_STATIC_ASSERT(std::numeric_limits::is_iec559, "'isCompNull' only accept floating-point inputs"); - return detail::compute_isCompNull::call(v, epsilon); + return detail::compute_isCompNull::call(v, epsilon); } - template - GLM_FUNC_QUALIFIER vec<2, bool, P> isCompNull - ( - vec<2, T, P> const & v, - T const & epsilon) + template + GLM_FUNC_QUALIFIER vec<2, bool, P> isCompNull(vec<2, T, P> const & v, T const & epsilon) { return vec<2, bool, P>( abs(v.x) < epsilon, abs(v.y) < epsilon); } - template - GLM_FUNC_QUALIFIER vec<3, bool, P> isCompNull - ( - vec<3, T, P> const & v, - T const & epsilon - ) + template + GLM_FUNC_QUALIFIER vec<3, bool, P> isCompNull(vec<3, T, P> const & v, T const& epsilon) { return vec<3, bool, P>( abs(v.x) < epsilon, @@ -165,12 +136,8 @@ namespace detail abs(v.z) < epsilon); } - template - GLM_FUNC_QUALIFIER vec<4, bool, P> isCompNull - ( - vec<4, T, P> const & v, - T const & epsilon - ) + template + GLM_FUNC_QUALIFIER vec<4, bool, P> isCompNull(vec<4, T, P> const & v, T const & epsilon) { return vec<4, bool, P>( abs(v.x) < epsilon, @@ -179,13 +146,8 @@ namespace detail abs(v.w) < epsilon); } - template class vecType> - GLM_FUNC_QUALIFIER bool areOrthonormal - ( - vecType const& v0, - vecType const& v1, - T const & epsilon - ) + template + GLM_FUNC_QUALIFIER bool areOrthonormal(vec const& v0, vec const& v1, T const & epsilon) { return isNormalized(v0, epsilon) && isNormalized(v1, epsilon) && (abs(dot(v0, v1)) <= epsilon); } diff --git a/glm/gtx/wrap.inl b/glm/gtx/wrap.inl index db10dabc..ff08f960 100644 --- a/glm/gtx/wrap.inl +++ b/glm/gtx/wrap.inl @@ -3,10 +3,10 @@ namespace glm { - template class vecType> - GLM_FUNC_QUALIFIER vecType clamp(vecType const& Texcoord) + template + GLM_FUNC_QUALIFIER vec clamp(vec const& Texcoord) { - return glm::clamp(Texcoord, vecType(0), vecType(1)); + return glm::clamp(Texcoord, vec(0), vec(1)); } template @@ -15,8 +15,8 @@ namespace glm return clamp(vec<1, genType, defaultp>(Texcoord)).x; } - template class vecType> - GLM_FUNC_QUALIFIER vecType repeat(vecType const& Texcoord) + template + GLM_FUNC_QUALIFIER vec repeat(vec const& Texcoord) { return glm::fract(Texcoord); } @@ -27,8 +27,8 @@ namespace glm return repeat(vec<1, genType, defaultp>(Texcoord)).x; } - template class vecType> - GLM_FUNC_QUALIFIER vecType mirrorClamp(vecType const& Texcoord) + template + GLM_FUNC_QUALIFIER vec mirrorClamp(vec const& Texcoord) { return glm::fract(glm::abs(Texcoord)); } @@ -39,15 +39,15 @@ namespace glm return mirrorClamp(vec<1, genType, defaultp>(Texcoord)).x; } - template class vecType> - GLM_FUNC_QUALIFIER vecType mirrorRepeat(vecType const& Texcoord) + template + GLM_FUNC_QUALIFIER vec mirrorRepeat(vec const& Texcoord) { - vecType const Abs = glm::abs(Texcoord); - vecType const Clamp = glm::mod(glm::floor(Abs), vecType(2)); - vecType const Floor = glm::floor(Abs); - vecType const Rest = Abs - Floor; - vecType const Mirror = Clamp + Rest; - return mix(Rest, vecType(1) - Rest, glm::greaterThanEqual(Mirror, vecType(1))); + vec const Abs = glm::abs(Texcoord); + vec const Clamp = glm::mod(glm::floor(Abs), vec(2)); + vec const Floor = glm::floor(Abs); + vec const Rest = Abs - Floor; + vec const Mirror = Clamp + Rest; + return mix(Rest, vec(1) - Rest, glm::greaterThanEqual(Mirror, vec(1))); } template diff --git a/glm/mat2x2.hpp b/glm/mat2x2.hpp index e4c3de19..bcfef4ba 100644 --- a/glm/mat2x2.hpp +++ b/glm/mat2x2.hpp @@ -9,43 +9,43 @@ namespace glm { - /// 2 columns of 2 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 2 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, lowp> lowp_mat2; - /// 2 columns of 2 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 2 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, mediump> mediump_mat2; - /// 2 columns of 2 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 2 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, highp> highp_mat2; - /// 2 columns of 2 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 2 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, lowp> lowp_mat2x2; - /// 2 columns of 2 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 2 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 2, float, mediump> mediump_mat2x2; - /// 2 columns of 2 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 2 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier diff --git a/glm/mat2x3.hpp b/glm/mat2x3.hpp index 16fd5428..bf0170f4 100644 --- a/glm/mat2x3.hpp +++ b/glm/mat2x3.hpp @@ -9,22 +9,22 @@ namespace glm { - /// 2 columns of 3 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 3 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 3, float, lowp> lowp_mat2x3; - /// 2 columns of 3 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 3 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 3, float, mediump> mediump_mat2x3; - /// 2 columns of 3 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 3 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier diff --git a/glm/mat2x4.hpp b/glm/mat2x4.hpp index 03983794..d7b1491c 100644 --- a/glm/mat2x4.hpp +++ b/glm/mat2x4.hpp @@ -9,22 +9,22 @@ namespace glm { - /// 2 columns of 4 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 4 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 4, float, lowp> lowp_mat2x4; - /// 2 columns of 4 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 4 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<2, 4, float, mediump> mediump_mat2x4; - /// 2 columns of 4 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 2 columns of 4 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier diff --git a/glm/mat3x2.hpp b/glm/mat3x2.hpp index 903122eb..70a7b25e 100644 --- a/glm/mat3x2.hpp +++ b/glm/mat3x2.hpp @@ -9,22 +9,22 @@ namespace glm { - /// 3 columns of 2 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 2 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 2, float, lowp> lowp_mat3x2; - /// 3 columns of 2 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 2 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 2, float, mediump> mediump_mat3x2; - /// 3 columns of 2 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 2 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier diff --git a/glm/mat3x3.hpp b/glm/mat3x3.hpp index fe7250b8..80e02e28 100644 --- a/glm/mat3x3.hpp +++ b/glm/mat3x3.hpp @@ -9,43 +9,43 @@ namespace glm { - /// 3 columns of 3 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 3 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, lowp> lowp_mat3; - /// 3 columns of 3 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 3 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, mediump> mediump_mat3; - /// 3 columns of 3 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 3 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, highp> highp_mat3; - /// 3 columns of 3 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 3 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, lowp> lowp_mat3x3; - /// 3 columns of 3 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 3 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 3, float, mediump> mediump_mat3x3; - /// 3 columns of 3 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 3 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier diff --git a/glm/mat3x4.hpp b/glm/mat3x4.hpp index 3e6cf7e7..74ab1c43 100644 --- a/glm/mat3x4.hpp +++ b/glm/mat3x4.hpp @@ -9,22 +9,22 @@ namespace glm { - /// 3 columns of 4 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 4 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 4, float, lowp> lowp_mat3x4; - /// 3 columns of 4 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 4 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<3, 4, float, mediump> mediump_mat3x4; - /// 3 columns of 4 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 3 columns of 4 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier diff --git a/glm/mat4x2.hpp b/glm/mat4x2.hpp index d92b1823..6d64a1f0 100644 --- a/glm/mat4x2.hpp +++ b/glm/mat4x2.hpp @@ -9,22 +9,22 @@ namespace glm { - /// 4 columns of 2 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 2 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 2, float, lowp> lowp_mat4x2; - /// 4 columns of 2 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 2 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 2, float, mediump> mediump_mat4x2; - /// 4 columns of 2 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 2 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier diff --git a/glm/mat4x3.hpp b/glm/mat4x3.hpp index a66bf459..ee8a8079 100644 --- a/glm/mat4x3.hpp +++ b/glm/mat4x3.hpp @@ -9,22 +9,22 @@ namespace glm { - /// 4 columns of 3 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 3 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 3, float, lowp> lowp_mat4x3; - /// 4 columns of 3 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 3 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 3, float, mediump> mediump_mat4x3; - /// 4 columns of 3 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 3 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier diff --git a/glm/mat4x4.hpp b/glm/mat4x4.hpp index 5f9c538c..d1ba41d1 100644 --- a/glm/mat4x4.hpp +++ b/glm/mat4x4.hpp @@ -9,43 +9,43 @@ namespace glm { - /// 4 columns of 4 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 4 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, lowp> lowp_mat4; - /// 4 columns of 4 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 4 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, mediump> mediump_mat4; - /// 4 columns of 4 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 4 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, highp> highp_mat4; - /// 4 columns of 4 components matrix of low precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 4 components matrix of low qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, lowp> lowp_mat4x4; - /// 4 columns of 4 components matrix of medium precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 4 components matrix of medium qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier typedef mat<4, 4, float, mediump> mediump_mat4x4; - /// 4 columns of 4 components matrix of high precision floating-point numbers. - /// There is no guarantee on the actual precision. + /// 4 columns of 4 components matrix of high qualifier floating-point numbers. + /// There is no guarantee on the actual qualifier. /// /// @see GLSL 4.20.8 specification, section 4.1.6 Matrices /// @see GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier diff --git a/test/core/core_func_integer.cpp b/test/core/core_func_integer.cpp index 0ce3bba3..55a06c5f 100644 --- a/test/core/core_func_integer.cpp +++ b/test/core/core_func_integer.cpp @@ -151,7 +151,7 @@ namespace bitfieldReverse return Result; } */ - template + template GLM_FUNC_QUALIFIER glm::vec bitfieldReverseLoop(glm::vec const& v) { GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldReverse' only accept integer values"); @@ -197,7 +197,7 @@ namespace bitfieldReverse template struct compute_bitfieldReverseStep { - template + template GLM_FUNC_QUALIFIER static glm::vec call(glm::vec const & v, T, T) { return v; @@ -207,14 +207,14 @@ namespace bitfieldReverse template<> struct compute_bitfieldReverseStep { - template + template GLM_FUNC_QUALIFIER static glm::vec call(glm::vec const & v, T Mask, T Shift) { return (v & Mask) << Shift | (v & (~Mask)) >> Shift; } }; - template + template GLM_FUNC_QUALIFIER glm::vec bitfieldReverseOps(glm::vec const & v) { glm::vec x(v); @@ -1397,7 +1397,7 @@ namespace bitCount template struct compute_bitfieldBitCountStep { - template + template GLM_FUNC_QUALIFIER static glm::vec call(glm::vec const& v, T, T) { return v; @@ -1407,14 +1407,14 @@ namespace bitCount template<> struct compute_bitfieldBitCountStep { - template + template GLM_FUNC_QUALIFIER static glm::vec call(glm::vec const& v, T Mask, T Shift) { return (v & Mask) + ((v >> Shift) & Mask); } }; - template + template static glm::vec bitCount_bitfield(glm::vec const & v) { glm::vec::type, P> x(*reinterpret_cast::type, P> const *>(&v)); diff --git a/test/core/core_func_integer_find_msb.cpp b/test/core/core_func_integer_find_msb.cpp index ea326c40..f37a44e4 100644 --- a/test/core/core_func_integer_find_msb.cpp +++ b/test/core/core_func_integer_find_msb.cpp @@ -168,7 +168,7 @@ int nlz7(unsigned k) return n; } - /* In single precision, round-to-nearest mode, the basic method fails for: + /* In single qualifier, round-to-nearest mode, the basic method fails for: k = 0, k = 01FFFFFF, 03FFFFFE <= k <= 03FFFFFF, 07FFFFFC <= k <= 07FFFFFF, 0FFFFFF8 <= k <= 0FFFFFFF, diff --git a/test/gtx/gtx_fast_trigonometry.cpp b/test/gtx/gtx_fast_trigonometry.cpp index c6474fb3..ffb7e438 100644 --- a/test/gtx/gtx_fast_trigonometry.cpp +++ b/test/gtx/gtx_fast_trigonometry.cpp @@ -173,17 +173,17 @@ namespace fastAtan namespace taylorCos { - using glm::precision; + using glm::qualifier; glm::vec4 const AngleShift(0.0f, glm::half_pi(), glm::pi(), glm::three_over_two_pi()); - template class vecType> - GLM_FUNC_QUALIFIER vecType taylorSeriesNewCos(vecType const & x) + template + GLM_FUNC_QUALIFIER glm::vec taylorSeriesNewCos(glm::vec const & x) { - vecType const Powed2(x * x); - vecType const Powed4(Powed2 * Powed2); - vecType const Powed6(Powed4 * Powed2); - vecType const Powed8(Powed4 * Powed4); + glm::vec const Powed2(x * x); + glm::vec const Powed4(Powed2 * Powed2); + glm::vec const Powed6(Powed4 * Powed2); + glm::vec const Powed8(Powed4 * Powed4); return static_cast(1) - Powed2 * static_cast(0.5) @@ -192,12 +192,12 @@ namespace taylorCos + Powed8 * static_cast(2.4801587301587301587301587301587e-5); } - template class vecType> - GLM_FUNC_QUALIFIER vecType taylorSeriesNewCos6(vecType const & x) + template + GLM_FUNC_QUALIFIER glm::vec taylorSeriesNewCos6(glm::vec const & x) { - vecType const Powed2(x * x); - vecType const Powed4(Powed2 * Powed2); - vecType const Powed6(Powed4 * Powed2); + glm::vec const Powed2(x * x); + glm::vec const Powed4(Powed2 * Powed2); + glm::vec const Powed6(Powed4 * Powed2); return static_cast(1) - Powed2 * static_cast(0.5) @@ -205,8 +205,8 @@ namespace taylorCos - Powed6 * static_cast(0.00138888888888888888888888888889); } - template class vecType> - GLM_FUNC_QUALIFIER vecType fastAbs(vecType x) + template + GLM_FUNC_QUALIFIER glm::vec fastAbs(glm::vec x) { int* Pointer = reinterpret_cast(&x[0]); Pointer[0] &= 0x7fffffff; @@ -216,17 +216,17 @@ namespace taylorCos return x; } - template class vecType> - GLM_FUNC_QUALIFIER vecType fastCosNew(vecType const & x) + template + GLM_FUNC_QUALIFIER glm::vec fastCosNew(glm::vec const & x) { - vecType const Angle0_PI(fastAbs(fmod(x + glm::pi(), glm::two_pi()) - glm::pi())); + glm::vec const Angle0_PI(fastAbs(fmod(x + glm::pi(), glm::two_pi()) - glm::pi())); return taylorSeriesNewCos6(x); /* - vecType const FirstQuarterPi(lessThanEqual(Angle0_PI, vecType(glm::half_pi()))); + vec const FirstQuarterPi(lessThanEqual(Angle0_PI, vec(glm::half_pi()))); - vecType const RevertAngle(mix(vecType(glm::pi()), vecType(0), FirstQuarterPi)); - vecType const ReturnSign(mix(vecType(-1), vecType(1), FirstQuarterPi)); - vecType const SectionAngle(RevertAngle - Angle0_PI); + vec const RevertAngle(mix(vec(glm::pi()), vec(0), FirstQuarterPi)); + vec const ReturnSign(mix(vec(-1), vec(1), FirstQuarterPi)); + vec const SectionAngle(RevertAngle - Angle0_PI); return ReturnSign * taylorSeriesNewCos(SectionAngle); */ @@ -254,21 +254,21 @@ namespace taylorCos return Error; } - template class vecType> - GLM_FUNC_QUALIFIER vecType deterministic_fmod(vecType const & x, T y) + template + GLM_FUNC_QUALIFIER glm::vec deterministic_fmod(glm::vec const & x, T y) { return x - y * trunc(x / y); } - template class vecType> - GLM_FUNC_QUALIFIER vecType fastCosDeterminisctic(vecType const & x) + template + GLM_FUNC_QUALIFIER glm::vec fastCosDeterminisctic(glm::vec const & x) { - vecType const Angle0_PI(abs(deterministic_fmod(x + glm::pi(), glm::two_pi()) - glm::pi())); - vecType const FirstQuarterPi(lessThanEqual(Angle0_PI, vecType(glm::half_pi()))); + glm::vec const Angle0_PI(abs(deterministic_fmod(x + glm::pi(), glm::two_pi()) - glm::pi())); + glm::vec const FirstQuarterPi(lessThanEqual(Angle0_PI, glm::vec(glm::half_pi()))); - vecType const RevertAngle(mix(vecType(glm::pi()), vecType(0), FirstQuarterPi)); - vecType const ReturnSign(mix(vecType(-1), vecType(1), FirstQuarterPi)); - vecType const SectionAngle(RevertAngle - Angle0_PI); + glm::vec const RevertAngle(mix(glm::vec(glm::pi()), glm::vec(0), FirstQuarterPi)); + glm::vec const ReturnSign(mix(glm::vec(-1), glm::vec(1), FirstQuarterPi)); + glm::vec const SectionAngle(RevertAngle - Angle0_PI); return ReturnSign * taylorSeriesNewCos(SectionAngle); } @@ -295,8 +295,8 @@ namespace taylorCos return Error; } - template class vecType> - GLM_FUNC_QUALIFIER vecType taylorSeriesRefCos(vecType const & x) + template + GLM_FUNC_QUALIFIER glm::vec taylorSeriesRefCos(glm::vec const & x) { return static_cast(1) - (x * x) / glm::factorial(static_cast(2)) @@ -305,17 +305,17 @@ namespace taylorCos + (x * x * x * x * x * x * x * x) / glm::factorial(static_cast(8)); } - template class vecType> - GLM_FUNC_QUALIFIER vecType fastRefCos(vecType const & x) + template + GLM_FUNC_QUALIFIER glm::vec fastRefCos(glm::vec const & x) { - vecType const Angle0_PI(glm::abs(fmod(x + glm::pi(), glm::two_pi()) - glm::pi())); + glm::vec const Angle0_PI(glm::abs(fmod(x + glm::pi(), glm::two_pi()) - glm::pi())); // return taylorSeriesRefCos(Angle0_PI); - vecType const FirstQuarterPi(lessThanEqual(Angle0_PI, vecType(glm::half_pi()))); + glm::vec const FirstQuarterPi(lessThanEqual(Angle0_PI, glm::vec(glm::half_pi()))); - vecType const RevertAngle(mix(vecType(glm::pi()), vecType(0), FirstQuarterPi)); - vecType const ReturnSign(mix(vecType(-1), vecType(1), FirstQuarterPi)); - vecType const SectionAngle(RevertAngle - Angle0_PI); + glm::vec const RevertAngle(mix(glm::vec(glm::pi()), glm::vec(0), FirstQuarterPi)); + glm::vec const ReturnSign(mix(glm::vec(-1), glm::vec(1), FirstQuarterPi)); + glm::vec const SectionAngle(RevertAngle - Angle0_PI); return ReturnSign * taylorSeriesRefCos(SectionAngle); } diff --git a/test/gtx/gtx_io.cpp b/test/gtx/gtx_io.cpp index a06d1cf6..3533a593 100644 --- a/test/gtx/gtx_io.cpp +++ b/test/gtx/gtx_io.cpp @@ -8,7 +8,7 @@ namespace { template - std::basic_ostream& operator<<(std::basic_ostream& os, glm::precision const& a) + std::basic_ostream& operator<<(std::basic_ostream& os, glm::qualifier const& a) { typename std::basic_ostream::sentry const cerberus(os); @@ -29,7 +29,7 @@ namespace return os; } - template + template std::basic_string type_name(std::basic_ostream&, T const&) { std::basic_ostringstream ostr; @@ -55,7 +55,7 @@ namespace } } // namespace { -template +template int test_io_quat(OS& os) { os << '\n' << typeid(OS).name() << '\n'; @@ -79,7 +79,7 @@ int test_io_quat(OS& os) return 0; } -template +template int test_io_vec(OS& os) { os << '\n' << typeid(OS).name() << '\n'; @@ -102,7 +102,7 @@ int test_io_vec(OS& os) return 0; } -template +template int test_io_mat(OS& os, glm::io::order_type otype) { os << '\n' << typeid(OS).name() << '\n'; diff --git a/test/gtx/gtx_matrix_factorisation.cpp b/test/gtx/gtx_matrix_factorisation.cpp index 7526d364..bf47b74a 100644 --- a/test/gtx/gtx_matrix_factorisation.cpp +++ b/test/gtx/gtx_matrix_factorisation.cpp @@ -3,7 +3,7 @@ #include #include -template class matType> +template class matType> int test_qr(matType m) { int Error = 0; @@ -40,7 +40,7 @@ int test_qr(matType m) return Error; } -template class matType> +template class matType> int test_rq(matType m) { int Error = 0;