From 40b30d43d33230b2eb453271629768fcafa52439 Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 17 Feb 2014 19:42:52 +0100 Subject: [PATCH] GLM (tool for opengl) update to 0.9.4.6 --- include/gal/opengl/glm/core/_detail.hpp | 11 +- include/gal/opengl/glm/core/_fixes.hpp | 2 +- include/gal/opengl/glm/core/_swizzle.hpp | 105 +++++---- include/gal/opengl/glm/core/_swizzle_func.hpp | 2 +- include/gal/opengl/glm/core/_vectorize.hpp | 2 +- include/gal/opengl/glm/core/dummy.cpp | 2 +- include/gal/opengl/glm/core/func_common.hpp | 100 ++++----- include/gal/opengl/glm/core/func_common.inl | 211 ++++++++++-------- .../gal/opengl/glm/core/func_exponential.hpp | 22 +- .../gal/opengl/glm/core/func_exponential.inl | 3 +- .../gal/opengl/glm/core/func_geometric.hpp | 18 +- .../gal/opengl/glm/core/func_geometric.inl | 5 +- include/gal/opengl/glm/core/func_integer.hpp | 26 +-- include/gal/opengl/glm/core/func_integer.inl | 20 +- include/gal/opengl/glm/core/func_matrix.hpp | 20 +- include/gal/opengl/glm/core/func_matrix.inl | 2 +- include/gal/opengl/glm/core/func_noise.hpp | 10 +- include/gal/opengl/glm/core/func_noise.inl | 2 +- include/gal/opengl/glm/core/func_packing.hpp | 26 +-- include/gal/opengl/glm/core/func_packing.inl | 38 +++- .../opengl/glm/core/func_trigonometric.hpp | 32 +-- .../opengl/glm/core/func_trigonometric.inl | 2 +- .../glm/core/func_vector_relational.hpp | 20 +- .../glm/core/func_vector_relational.inl | 2 +- include/gal/opengl/glm/core/hint.hpp | 2 +- .../gal/opengl/glm/core/intrinsic_common.hpp | 2 +- .../gal/opengl/glm/core/intrinsic_common.inl | 2 +- .../opengl/glm/core/intrinsic_exponential.hpp | 2 +- .../opengl/glm/core/intrinsic_exponential.inl | 2 +- .../opengl/glm/core/intrinsic_geometric.hpp | 2 +- .../opengl/glm/core/intrinsic_geometric.inl | 2 +- .../gal/opengl/glm/core/intrinsic_matrix.hpp | 2 +- .../gal/opengl/glm/core/intrinsic_matrix.inl | 2 +- .../glm/core/intrinsic_trigonometric.hpp | 2 +- .../glm/core/intrinsic_trigonometric.inl | 2 +- .../glm/core/intrinsic_vector_relational.hpp | 2 +- .../glm/core/intrinsic_vector_relational.inl | 2 +- include/gal/opengl/glm/core/setup.hpp | 166 +++++++------- include/gal/opengl/glm/core/type.hpp | 2 +- include/gal/opengl/glm/core/type_float.hpp | 2 +- include/gal/opengl/glm/core/type_gentype.hpp | 2 +- include/gal/opengl/glm/core/type_gentype.inl | 2 +- include/gal/opengl/glm/core/type_half.hpp | 32 +-- include/gal/opengl/glm/core/type_half.inl | 8 +- include/gal/opengl/glm/core/type_int.hpp | 10 +- include/gal/opengl/glm/core/type_mat.hpp | 36 +-- include/gal/opengl/glm/core/type_mat.inl | 2 +- include/gal/opengl/glm/core/type_mat2x2.hpp | 52 ++--- include/gal/opengl/glm/core/type_mat2x2.inl | 22 +- include/gal/opengl/glm/core/type_mat2x3.hpp | 46 ++-- include/gal/opengl/glm/core/type_mat2x3.inl | 22 +- include/gal/opengl/glm/core/type_mat2x4.hpp | 42 ++-- include/gal/opengl/glm/core/type_mat2x4.inl | 24 +- include/gal/opengl/glm/core/type_mat3x2.hpp | 58 ++--- include/gal/opengl/glm/core/type_mat3x2.inl | 22 +- include/gal/opengl/glm/core/type_mat3x3.hpp | 52 ++--- include/gal/opengl/glm/core/type_mat3x3.inl | 22 +- include/gal/opengl/glm/core/type_mat3x4.hpp | 46 ++-- include/gal/opengl/glm/core/type_mat3x4.inl | 22 +- include/gal/opengl/glm/core/type_mat4x2.hpp | 42 ++-- include/gal/opengl/glm/core/type_mat4x2.inl | 22 +- include/gal/opengl/glm/core/type_mat4x3.hpp | 46 ++-- include/gal/opengl/glm/core/type_mat4x3.inl | 22 +- include/gal/opengl/glm/core/type_mat4x4.hpp | 52 ++--- include/gal/opengl/glm/core/type_mat4x4.inl | 24 +- include/gal/opengl/glm/core/type_size.hpp | 2 +- include/gal/opengl/glm/core/type_vec.hpp | 2 +- include/gal/opengl/glm/core/type_vec.inl | 2 +- include/gal/opengl/glm/core/type_vec1.hpp | 2 +- include/gal/opengl/glm/core/type_vec1.inl | 2 +- include/gal/opengl/glm/core/type_vec2.hpp | 32 +-- include/gal/opengl/glm/core/type_vec2.inl | 52 +---- include/gal/opengl/glm/core/type_vec3.hpp | 30 +-- include/gal/opengl/glm/core/type_vec3.inl | 52 +---- include/gal/opengl/glm/core/type_vec4.hpp | 30 +-- include/gal/opengl/glm/core/type_vec4.inl | 52 +---- include/gal/opengl/glm/ext.hpp | 2 +- include/gal/opengl/glm/glm.hpp | 2 +- include/gal/opengl/glm/gtc/constants.hpp | 52 ++--- include/gal/opengl/glm/gtc/constants.inl | 2 +- include/gal/opengl/glm/gtc/epsilon.hpp | 2 +- include/gal/opengl/glm/gtc/epsilon.inl | 2 +- include/gal/opengl/glm/gtc/half_float.hpp | 208 +++++++++-------- include/gal/opengl/glm/gtc/half_float.inl | 13 +- include/gal/opengl/glm/gtc/matrix_access.hpp | 2 +- include/gal/opengl/glm/gtc/matrix_access.inl | 2 +- include/gal/opengl/glm/gtc/matrix_integer.hpp | 2 +- include/gal/opengl/glm/gtc/matrix_inverse.hpp | 2 +- include/gal/opengl/glm/gtc/matrix_inverse.inl | 2 +- .../gal/opengl/glm/gtc/matrix_transform.hpp | 2 +- .../gal/opengl/glm/gtc/matrix_transform.inl | 20 +- include/gal/opengl/glm/gtc/noise.hpp | 2 +- include/gal/opengl/glm/gtc/noise.inl | 2 +- include/gal/opengl/glm/gtc/quaternion.hpp | 2 +- include/gal/opengl/glm/gtc/quaternion.inl | 14 +- include/gal/opengl/glm/gtc/random.hpp | 2 +- include/gal/opengl/glm/gtc/random.inl | 2 +- include/gal/opengl/glm/gtc/reciprocal.hpp | 2 +- include/gal/opengl/glm/gtc/reciprocal.inl | 2 +- include/gal/opengl/glm/gtc/swizzle.hpp | 2 +- include/gal/opengl/glm/gtc/swizzle.inl | 2 +- include/gal/opengl/glm/gtc/type_precision.hpp | 2 +- include/gal/opengl/glm/gtc/type_precision.inl | 2 +- include/gal/opengl/glm/gtc/type_ptr.hpp | 2 +- include/gal/opengl/glm/gtc/type_ptr.inl | 19 +- include/gal/opengl/glm/gtc/ulp.hpp | 2 +- include/gal/opengl/glm/gtc/ulp.inl | 12 +- .../gal/opengl/glm/gtx/associated_min_max.hpp | 2 +- .../gal/opengl/glm/gtx/associated_min_max.inl | 2 +- include/gal/opengl/glm/gtx/bit.hpp | 2 +- include/gal/opengl/glm/gtx/bit.inl | 2 +- include/gal/opengl/glm/gtx/closest_point.hpp | 2 +- include/gal/opengl/glm/gtx/closest_point.inl | 2 +- include/gal/opengl/glm/gtx/color_cast.hpp | 2 +- include/gal/opengl/glm/gtx/color_cast.inl | 2 +- include/gal/opengl/glm/gtx/color_space.hpp | 2 +- include/gal/opengl/glm/gtx/color_space.inl | 2 +- .../gal/opengl/glm/gtx/color_space_YCoCg.hpp | 2 +- .../gal/opengl/glm/gtx/color_space_YCoCg.inl | 2 +- include/gal/opengl/glm/gtx/compatibility.hpp | 2 +- include/gal/opengl/glm/gtx/compatibility.inl | 2 +- include/gal/opengl/glm/gtx/component_wise.hpp | 2 +- include/gal/opengl/glm/gtx/component_wise.inl | 4 +- include/gal/opengl/glm/gtx/constants.hpp | 2 +- include/gal/opengl/glm/gtx/epsilon.hpp | 2 +- include/gal/opengl/glm/gtx/euler_angles.hpp | 2 +- include/gal/opengl/glm/gtx/euler_angles.inl | 6 +- include/gal/opengl/glm/gtx/extend.hpp | 2 +- include/gal/opengl/glm/gtx/extend.inl | 2 +- .../gal/opengl/glm/gtx/extented_min_max.hpp | 2 +- .../gal/opengl/glm/gtx/extented_min_max.inl | 2 +- .../gal/opengl/glm/gtx/fast_exponential.hpp | 2 +- .../gal/opengl/glm/gtx/fast_exponential.inl | 2 +- .../gal/opengl/glm/gtx/fast_square_root.hpp | 2 +- .../gal/opengl/glm/gtx/fast_square_root.inl | 2 +- .../gal/opengl/glm/gtx/fast_trigonometry.hpp | 2 +- .../gal/opengl/glm/gtx/fast_trigonometry.inl | 2 +- include/gal/opengl/glm/gtx/gradient_paint.hpp | 2 +- include/gal/opengl/glm/gtx/gradient_paint.inl | 2 +- .../glm/gtx/handed_coordinate_space.hpp | 2 +- .../glm/gtx/handed_coordinate_space.inl | 2 +- include/gal/opengl/glm/gtx/inertia.hpp | 2 +- include/gal/opengl/glm/gtx/inertia.inl | 2 +- include/gal/opengl/glm/gtx/int_10_10_10_2.hpp | 2 +- include/gal/opengl/glm/gtx/int_10_10_10_2.inl | 2 +- include/gal/opengl/glm/gtx/integer.hpp | 2 +- include/gal/opengl/glm/gtx/integer.inl | 2 +- include/gal/opengl/glm/gtx/intersect.hpp | 2 +- include/gal/opengl/glm/gtx/intersect.inl | 2 +- include/gal/opengl/glm/gtx/log_base.hpp | 2 +- include/gal/opengl/glm/gtx/log_base.inl | 2 +- .../opengl/glm/gtx/matrix_cross_product.hpp | 2 +- .../opengl/glm/gtx/matrix_cross_product.inl | 2 +- .../opengl/glm/gtx/matrix_interpolation.hpp | 2 +- .../opengl/glm/gtx/matrix_interpolation.inl | 7 +- .../opengl/glm/gtx/matrix_major_storage.hpp | 2 +- .../opengl/glm/gtx/matrix_major_storage.inl | 2 +- .../gal/opengl/glm/gtx/matrix_operation.hpp | 2 +- .../gal/opengl/glm/gtx/matrix_operation.inl | 2 +- include/gal/opengl/glm/gtx/matrix_query.hpp | 2 +- include/gal/opengl/glm/gtx/matrix_query.inl | 2 +- include/gal/opengl/glm/gtx/mixed_product.hpp | 2 +- include/gal/opengl/glm/gtx/mixed_product.inl | 2 +- include/gal/opengl/glm/gtx/multiple.hpp | 2 +- include/gal/opengl/glm/gtx/multiple.inl | 20 +- include/gal/opengl/glm/gtx/noise.hpp | 2 +- include/gal/opengl/glm/gtx/norm.hpp | 2 +- include/gal/opengl/glm/gtx/norm.inl | 2 +- include/gal/opengl/glm/gtx/normal.hpp | 2 +- include/gal/opengl/glm/gtx/normal.inl | 2 +- include/gal/opengl/glm/gtx/normalize_dot.hpp | 2 +- include/gal/opengl/glm/gtx/normalize_dot.inl | 2 +- .../gal/opengl/glm/gtx/number_precision.hpp | 2 +- .../gal/opengl/glm/gtx/number_precision.inl | 2 +- include/gal/opengl/glm/gtx/ocl_type.hpp | 10 +- include/gal/opengl/glm/gtx/ocl_type.inl | 27 +++ include/gal/opengl/glm/gtx/optimum_pow.hpp | 2 +- include/gal/opengl/glm/gtx/optimum_pow.inl | 2 +- include/gal/opengl/glm/gtx/orthonormalize.hpp | 2 +- include/gal/opengl/glm/gtx/orthonormalize.inl | 2 +- include/gal/opengl/glm/gtx/perpendicular.hpp | 2 +- include/gal/opengl/glm/gtx/perpendicular.inl | 2 +- .../gal/opengl/glm/gtx/polar_coordinates.hpp | 14 +- .../gal/opengl/glm/gtx/polar_coordinates.inl | 4 +- include/gal/opengl/glm/gtx/projection.hpp | 2 +- include/gal/opengl/glm/gtx/projection.inl | 2 +- include/gal/opengl/glm/gtx/quaternion.hpp | 5 +- include/gal/opengl/glm/gtx/quaternion.inl | 15 +- include/gal/opengl/glm/gtx/random.hpp | 2 +- include/gal/opengl/glm/gtx/raw_data.hpp | 2 +- include/gal/opengl/glm/gtx/raw_data.inl | 2 +- include/gal/opengl/glm/gtx/reciprocal.hpp | 2 +- include/gal/opengl/glm/gtx/rotate_vector.hpp | 2 +- include/gal/opengl/glm/gtx/rotate_vector.inl | 8 +- include/gal/opengl/glm/gtx/simd_mat4.hpp | 2 +- include/gal/opengl/glm/gtx/simd_mat4.inl | 2 +- include/gal/opengl/glm/gtx/simd_vec4.hpp | 6 +- include/gal/opengl/glm/gtx/simd_vec4.inl | 4 +- include/gal/opengl/glm/gtx/spline.hpp | 2 +- include/gal/opengl/glm/gtx/spline.inl | 2 +- include/gal/opengl/glm/gtx/std_based_type.hpp | 2 +- include/gal/opengl/glm/gtx/std_based_type.inl | 2 +- include/gal/opengl/glm/gtx/string_cast.hpp | 2 +- include/gal/opengl/glm/gtx/transform.hpp | 2 +- include/gal/opengl/glm/gtx/transform.inl | 2 +- include/gal/opengl/glm/gtx/transform2.hpp | 2 +- include/gal/opengl/glm/gtx/transform2.inl | 2 +- include/gal/opengl/glm/gtx/ulp.hpp | 2 +- include/gal/opengl/glm/gtx/unsigned_int.hpp | 2 +- include/gal/opengl/glm/gtx/unsigned_int.inl | 2 +- include/gal/opengl/glm/gtx/vec1.hpp | 2 +- include/gal/opengl/glm/gtx/vec1.inl | 27 +++ include/gal/opengl/glm/gtx/vector_access.hpp | 2 +- include/gal/opengl/glm/gtx/vector_access.inl | 2 +- include/gal/opengl/glm/gtx/vector_angle.hpp | 2 +- include/gal/opengl/glm/gtx/vector_angle.inl | 2 +- include/gal/opengl/glm/gtx/vector_query.hpp | 2 +- include/gal/opengl/glm/gtx/vector_query.inl | 2 +- .../gal/opengl/glm/gtx/verbose_operator.hpp | 2 +- .../gal/opengl/glm/gtx/verbose_operator.inl | 2 +- include/gal/opengl/glm/gtx/wrap.hpp | 2 +- include/gal/opengl/glm/gtx/wrap.inl | 2 +- include/gal/opengl/glm/virtrev/xstream.hpp | 2 +- 223 files changed, 1298 insertions(+), 1316 deletions(-) diff --git a/include/gal/opengl/glm/core/_detail.hpp b/include/gal/opengl/glm/core/_detail.hpp index ecc9250ecf..e6b42c26ed 100644 --- a/include/gal/opengl/glm/core/_detail.hpp +++ b/include/gal/opengl/glm/core/_detail.hpp @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights @@ -445,7 +445,14 @@ namespace detail # define GLM_RESTRICT __declspec(restrict) # define GLM_RESTRICT_VAR __restrict # define GLM_CONSTEXPR -#elif((GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_LLVM_GCC)) && (GLM_COMPILER >= GLM_COMPILER_GCC31)) +#elif(GLM_COMPILER & GLM_COMPILER_INTEL) +# define GLM_DEPRECATED +# define GLM_ALIGN(x) __declspec(align(x)) +# define GLM_ALIGNED_STRUCT(x) __declspec(align(x)) struct +# define GLM_RESTRICT +# define GLM_RESTRICT_VAR __restrict +# define GLM_CONSTEXPR +#elif(((GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_LLVM_GCC)) && (GLM_COMPILER >= GLM_COMPILER_GCC31)) || (GLM_COMPILER & GLM_COMPILER_CLANG)) # define GLM_DEPRECATED __attribute__((__deprecated__)) # define GLM_ALIGN(x) __attribute__((aligned(x))) # define GLM_ALIGNED_STRUCT(x) struct __attribute__((aligned(x))) diff --git a/include/gal/opengl/glm/core/_fixes.hpp b/include/gal/opengl/glm/core/_fixes.hpp index 1b4dddaac7..b4cec5f259 100644 --- a/include/gal/opengl/glm/core/_fixes.hpp +++ b/include/gal/opengl/glm/core/_fixes.hpp @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights diff --git a/include/gal/opengl/glm/core/_swizzle.hpp b/include/gal/opengl/glm/core/_swizzle.hpp index e234a02719..dc069443f7 100644 --- a/include/gal/opengl/glm/core/_swizzle.hpp +++ b/include/gal/opengl/glm/core/_swizzle.hpp @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights @@ -60,8 +60,8 @@ namespace detail typedef T value_type; protected: - value_type& elem (size_t i) { return (reinterpret_cast(_buffer))[i]; } - const value_type& elem (size_t i) const { return (reinterpret_cast(_buffer))[i]; } + GLM_FUNC_QUALIFIER value_type& elem (size_t i) { return (reinterpret_cast(_buffer))[i]; } + GLM_FUNC_QUALIFIER const value_type& elem (size_t i) const { return (reinterpret_cast(_buffer))[i]; } // Use an opaque buffer to *ensure* the compiler doesn't call a constructor. // The size 1 buffer is assumed to aligned to the actual members so that the @@ -77,19 +77,19 @@ namespace detail template struct _swizzle_base1 : public _swizzle_base0 { - V operator ()() const { return V(this->elem(E0), this->elem(E1)); } + GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0), this->elem(E1)); } }; template struct _swizzle_base1 : public _swizzle_base0 { - V operator ()() const { return V(this->elem(E0), this->elem(E1), this->elem(E2)); } + GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0), this->elem(E1), this->elem(E2)); } }; template struct _swizzle_base1 : public _swizzle_base0 { - V operator ()() const { return V(this->elem(E0), this->elem(E1), this->elem(E2), this->elem(E3)); } + GLM_FUNC_QUALIFIER V operator ()() const { return V(this->elem(E0), this->elem(E1), this->elem(E2), this->elem(E3)); } }; // Internal class for implementing swizzle operators @@ -110,67 +110,73 @@ namespace detail typedef VecType vec_type; typedef ValueType value_type; - _swizzle_base2& operator= (const ValueType& t) + GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const ValueType& t) { for (int i = 0; i < N; ++i) (*this)[i] = t; return *this; } - _swizzle_base2& operator= (const VecType& that) + GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const VecType& that) { struct op { - void operator() (value_type& e, value_type& t) { e = t; } + GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e = t; } }; _apply_op(that, op()); return *this; } - void operator -= (const VecType& that) + GLM_FUNC_QUALIFIER void operator -= (const VecType& that) { struct op { - void operator() (value_type& e, value_type& t) { e -= t; } + GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e -= t; } }; _apply_op(that, op()); } - void operator += (const VecType& that) + GLM_FUNC_QUALIFIER void operator += (const VecType& that) { struct op { - void operator() (value_type& e, value_type& t) { e += t; } + GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e += t; } }; _apply_op(that, op()); } - void operator *= (const VecType& that) + GLM_FUNC_QUALIFIER void operator *= (const VecType& that) { struct op { - void operator() (value_type& e, value_type& t) { e *= t; } + GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e *= t; } }; _apply_op(that, op()); } - void operator /= (const VecType& that) + GLM_FUNC_QUALIFIER void operator /= (const VecType& that) { struct op { - void operator() (value_type& e, value_type& t) { e /= t; } + GLM_FUNC_QUALIFIER void operator() (value_type& e, value_type& t) { e /= t; } }; _apply_op(that, op()); } - value_type& operator[] (size_t i) + GLM_FUNC_QUALIFIER value_type& operator[] (size_t i) { - static const int offset_dst[4] = { E0, E1, E2, E3 }; +#ifndef __CUDA_ARCH__ + static +#endif + const int offset_dst[4] = { E0, E1, E2, E3 }; return this->elem(offset_dst[i]); } - value_type operator[] (size_t i) const + GLM_FUNC_QUALIFIER value_type operator[] (size_t i) const { - static const int offset_dst[4] = { E0, E1, E2, E3 }; +#ifndef __CUDA_ARCH__ + static +#endif + const int offset_dst[4] = { E0, E1, E2, E3 }; return this->elem(offset_dst[i]); } protected: template - void _apply_op(const VecType& that, T op) + GLM_FUNC_QUALIFIER void _apply_op(const VecType& that, T op) { // Make a copy of the data in this == &that. // The copier should optimize out the copy in cases where the function is @@ -191,11 +197,14 @@ namespace detail typedef ValueType value_type; struct Stub {}; - _swizzle_base2& operator= (Stub const &) {} + GLM_FUNC_QUALIFIER _swizzle_base2& operator= (Stub const &) { return *this; } - value_type operator[] (size_t i) const + GLM_FUNC_QUALIFIER value_type operator[] (size_t i) const { - static const int offset_dst[4] = { E0, E1, E2, E3 }; +#ifndef __CUDA_ARCH__ + static +#endif + const int offset_dst[4] = { E0, E1, E2, E3 }; return this->elem(offset_dst[i]); } }; @@ -207,7 +216,7 @@ namespace detail using base_type::operator=; - operator VecType () const { return (*this)(); } + GLM_FUNC_QUALIFIER operator VecType () const { return (*this)(); } }; // @@ -223,17 +232,17 @@ namespace detail // #define _GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \ _GLM_SWIZZLE_TEMPLATE2 \ - V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b) \ + GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b) \ { \ return a() OPERAND b(); \ } \ _GLM_SWIZZLE_TEMPLATE1 \ - V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const V& b) \ + GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const V& b) \ { \ return a() OPERAND b; \ } \ _GLM_SWIZZLE_TEMPLATE1 \ - V operator OPERAND ( const V& a, const _GLM_SWIZZLE_TYPE1& b) \ + GLM_FUNC_QUALIFIER V operator OPERAND ( const V& a, const _GLM_SWIZZLE_TYPE1& b) \ { \ return a OPERAND b(); \ } @@ -243,12 +252,12 @@ namespace detail // #define _GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \ _GLM_SWIZZLE_TEMPLATE1 \ - V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const T& b) \ + GLM_FUNC_QUALIFIER V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const T& b) \ { \ return a() OPERAND b; \ } \ _GLM_SWIZZLE_TEMPLATE1 \ - V operator OPERAND ( const T& a, const _GLM_SWIZZLE_TYPE1& b) \ + GLM_FUNC_QUALIFIER V operator OPERAND ( const T& a, const _GLM_SWIZZLE_TYPE1& b) \ { \ return a OPERAND b(); \ } @@ -258,7 +267,7 @@ namespace detail // #define _GLM_SWIZZLE_FUNCTION_1_ARGS(RETURN_TYPE,FUNCTION) \ _GLM_SWIZZLE_TEMPLATE1 \ - typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a) \ + GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a) \ { \ return FUNCTION(a()); \ } @@ -268,22 +277,22 @@ namespace detail // #define _GLM_SWIZZLE_FUNCTION_2_ARGS(RETURN_TYPE,FUNCTION) \ _GLM_SWIZZLE_TEMPLATE2 \ - typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b) \ + GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b) \ { \ return FUNCTION(a(), b()); \ } \ _GLM_SWIZZLE_TEMPLATE1 \ - typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b) \ + GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b) \ { \ return FUNCTION(a(), b()); \ } \ _GLM_SWIZZLE_TEMPLATE1 \ - typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename V& b) \ + GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename V& b) \ { \ return FUNCTION(a(), b); \ } \ _GLM_SWIZZLE_TEMPLATE1 \ - typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const V& a, const _GLM_SWIZZLE_TYPE1& b) \ + GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const V& a, const _GLM_SWIZZLE_TYPE1& b) \ { \ return FUNCTION(a, b()); \ } @@ -293,22 +302,22 @@ namespace detail // #define _GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(RETURN_TYPE,FUNCTION) \ _GLM_SWIZZLE_TEMPLATE2 \ - typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b, const T& c) \ + GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b, const T& c) \ { \ return FUNCTION(a(), b(), c); \ } \ _GLM_SWIZZLE_TEMPLATE1 \ - typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b, const T& c) \ + GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b, const T& c) \ { \ return FUNCTION(a(), b(), c); \ } \ _GLM_SWIZZLE_TEMPLATE1 \ - typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename S0::vec_type& b, const T& c)\ + GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename S0::vec_type& b, const T& c)\ { \ return FUNCTION(a(), b, c); \ } \ _GLM_SWIZZLE_TEMPLATE1 \ - typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const typename V& a, const _GLM_SWIZZLE_TYPE1& b, const T& c) \ + GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const typename V& a, const _GLM_SWIZZLE_TYPE1& b, const T& c) \ { \ return FUNCTION(a, b(), c); \ } @@ -640,6 +649,22 @@ namespace glm struct { glm::detail::swizzle<4,T,P,0,2,3,1> E0 ## E2 ## E3 ## E1; }; \ struct { glm::detail::swizzle<4,T,P,0,2,3,2> E0 ## E2 ## E3 ## E2; }; \ struct { glm::detail::swizzle<4,T,P,0,2,3,3> E0 ## E2 ## E3 ## E3; }; \ + struct { glm::detail::swizzle<4,T,P,0,3,0,0> E0 ## E3 ## E0 ## E0; }; \ + struct { glm::detail::swizzle<4,T,P,0,3,0,1> E0 ## E3 ## E0 ## E1; }; \ + struct { glm::detail::swizzle<4,T,P,0,3,0,2> E0 ## E3 ## E0 ## E2; }; \ + struct { glm::detail::swizzle<4,T,P,0,3,0,3> E0 ## E3 ## E0 ## E3; }; \ + struct { glm::detail::swizzle<4,T,P,0,3,1,0> E0 ## E3 ## E1 ## E0; }; \ + struct { glm::detail::swizzle<4,T,P,0,3,1,1> E0 ## E3 ## E1 ## E1; }; \ + struct { glm::detail::swizzle<4,T,P,0,3,1,2> E0 ## E3 ## E1 ## E2; }; \ + struct { glm::detail::swizzle<4,T,P,0,3,1,3> E0 ## E3 ## E1 ## E3; }; \ + struct { glm::detail::swizzle<4,T,P,0,3,2,0> E0 ## E3 ## E2 ## E0; }; \ + struct { glm::detail::swizzle<4,T,P,0,3,2,1> E0 ## E3 ## E2 ## E1; }; \ + struct { glm::detail::swizzle<4,T,P,0,3,2,2> E0 ## E3 ## E2 ## E2; }; \ + struct { glm::detail::swizzle<4,T,P,0,3,2,3> E0 ## E3 ## E2 ## E3; }; \ + struct { glm::detail::swizzle<4,T,P,0,3,3,0> E0 ## E3 ## E3 ## E0; }; \ + struct { glm::detail::swizzle<4,T,P,0,3,3,1> E0 ## E3 ## E3 ## E1; }; \ + struct { glm::detail::swizzle<4,T,P,0,3,3,2> E0 ## E3 ## E3 ## E2; }; \ + struct { glm::detail::swizzle<4,T,P,0,3,3,3> E0 ## E3 ## E3 ## E3; }; \ struct { glm::detail::swizzle<4,T,P,1,0,0,0> E1 ## E0 ## E0 ## E0; }; \ struct { glm::detail::swizzle<4,T,P,1,0,0,1> E1 ## E0 ## E0 ## E1; }; \ struct { glm::detail::swizzle<4,T,P,1,0,0,2> E1 ## E0 ## E0 ## E2; }; \ diff --git a/include/gal/opengl/glm/core/_swizzle_func.hpp b/include/gal/opengl/glm/core/_swizzle_func.hpp index 255a3ec980..be66784373 100644 --- a/include/gal/opengl/glm/core/_swizzle_func.hpp +++ b/include/gal/opengl/glm/core/_swizzle_func.hpp @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights diff --git a/include/gal/opengl/glm/core/_vectorize.hpp b/include/gal/opengl/glm/core/_vectorize.hpp index 7e14cc17ef..9984014fa8 100644 --- a/include/gal/opengl/glm/core/_vectorize.hpp +++ b/include/gal/opengl/glm/core/_vectorize.hpp @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights diff --git a/include/gal/opengl/glm/core/dummy.cpp b/include/gal/opengl/glm/core/dummy.cpp index db03cf8970..38fcca0206 100644 --- a/include/gal/opengl/glm/core/dummy.cpp +++ b/include/gal/opengl/glm/core/dummy.cpp @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights diff --git a/include/gal/opengl/glm/core/func_common.hpp b/include/gal/opengl/glm/core/func_common.hpp index 9ed943ccf6..fcf7eb7619 100644 --- a/include/gal/opengl/glm/core/func_common.hpp +++ b/include/gal/opengl/glm/core/func_common.hpp @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights @@ -50,7 +50,7 @@ namespace glm /// @see GLSL abs man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template - genType abs(genType const & x); + GLM_FUNC_DECL genType abs(genType const & x); /// Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0. /// @@ -59,7 +59,7 @@ namespace glm /// @see GLSL sign man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template - genType sign(genType const & x); + GLM_FUNC_DECL genType sign(genType const & x); /// Returns a value equal to the nearest integer that is less then or equal to x. /// @@ -68,7 +68,7 @@ namespace glm /// @see GLSL floor man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template - genType floor(genType const & x); + GLM_FUNC_DECL genType floor(genType const & x); /// Returns a value equal to the nearest integer to x /// whose absolute value is not larger than the absolute value of x. @@ -78,7 +78,7 @@ namespace glm /// @see GLSL trunc man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template - genType trunc(genType const & x); + GLM_FUNC_DECL genType trunc(genType const & x); /// Returns a value equal to the nearest integer to x. /// The fraction 0.5 will round in a direction chosen by the @@ -91,7 +91,7 @@ namespace glm /// @see GLSL round man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template - genType round(genType const & x); + GLM_FUNC_DECL genType round(genType const & x); /// Returns a value equal to the nearest integer to x. /// A fractional part of 0.5 will round toward the nearest even @@ -103,7 +103,7 @@ namespace glm /// @see GLSL 4.20.8 specification, section 8.3 Common Functions /// @see New round to even technique template - genType roundEven(genType const & x); + GLM_FUNC_DECL genType roundEven(genType const & x); /// Returns a value equal to the nearest integer /// that is greater than or equal to x. @@ -113,7 +113,7 @@ namespace glm /// @see GLSL ceil man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template - genType ceil(genType const & x); + GLM_FUNC_DECL genType ceil(genType const & x); /// Return x - floor(x). /// @@ -122,7 +122,7 @@ namespace glm /// @see GLSL fract man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template - genType fract(genType const & x); + GLM_FUNC_DECL genType fract(genType const & x); /// Modulus. Returns x - y * floor(x / y) /// for each component in x using the floating point value y. @@ -132,7 +132,7 @@ namespace glm /// @see GLSL mod man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template - genType mod( + GLM_FUNC_DECL genType mod( genType const & x, genType const & y); @@ -144,7 +144,7 @@ namespace glm /// @see GLSL mod man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template - genType mod( + GLM_FUNC_DECL genType mod( genType const & x, typename genType::value_type const & y); @@ -158,7 +158,7 @@ namespace glm /// @see GLSL modf man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template - genType modf( + GLM_FUNC_DECL genType modf( genType const & x, genType & i); @@ -169,12 +169,12 @@ namespace glm /// @see GLSL min man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template - genType min( + GLM_FUNC_DECL genType min( genType const & x, genType const & y); template - genType min( + GLM_FUNC_DECL genType min( genType const & x, typename genType::value_type const & y); @@ -185,12 +185,12 @@ namespace glm /// @see GLSL max man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template - genType max( + GLM_FUNC_DECL genType max( genType const & x, genType const & y); template - genType max( + GLM_FUNC_DECL genType max( genType const & x, typename genType::value_type const & y); @@ -202,33 +202,33 @@ namespace glm /// @see GLSL clamp man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template - genType clamp( + GLM_FUNC_DECL genType clamp( genType const & x, genType const & minVal, genType const & maxVal); template - genType clamp( + GLM_FUNC_DECL genType clamp( genType const & x, typename genType::value_type const & minVal, typename genType::value_type const & maxVal); - //! @return If genTypeU is a floating scalar or vector: - //! 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]. - //! - //! @return If genTypeU is a boolean scalar or vector: - //! Selects which vector each returned component comes - //! from. For a component of a that is false, the - //! corresponding component of x is returned. For a - //! component of a that is true, the corresponding - //! component of y is returned. Components of x and y that - //! are not selected are allowed to be invalid floating point - //! values and will have no effect on the results. Thus, this - //! provides different functionality than - //! genType mix(genType x, genType y, genType(a)) - //! where a is a Boolean vector. + /// If genTypeU is a floating scalar or vector: + /// 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]. + /// + /// If genTypeU is a boolean scalar or vector: + /// Selects which vector each returned component comes + /// from. For a component of that is false, the + /// corresponding component of x is returned. For a + /// component of a that is true, the corresponding + /// component of y is returned. Components of x and y that + /// are not selected are allowed to be invalid floating point + /// values and will have no effect on the results. Thus, this + /// provides different functionality than + /// genType mix(genType x, genType y, genType(a)) + /// where a is a Boolean vector. /// /// @see GLSL mix man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions @@ -256,19 +256,19 @@ namespace glm /// glm::vec4 u = glm::mix(g, h, r); // Interpolations can be perform per component with a vector for the last parameter. /// @endcode template - genTypeT mix(genTypeT const & x, genTypeT const & y, genTypeU const & a); + GLM_FUNC_DECL genTypeT mix(genTypeT const & x, genTypeT const & y, genTypeU const & a); //! Returns 0.0 if x < edge, otherwise it returns 1.0. //! /// @see GLSL step man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template - genType step( + GLM_FUNC_DECL genType step( genType const & edge, genType const & x); template - genType step( + GLM_FUNC_DECL genType step( typename genType::value_type const & edge, genType const & x); @@ -278,8 +278,8 @@ namespace glm /// you would want a threshold function with a smooth /// transition. This is equivalent to: /// genType t; - /// t = clamp ((x – edge0) / (edge1 – edge0), 0, 1); - /// return t * t * (3 – 2 * t); + /// t = clamp ((x - edge0) / (edge1 - edge0), 0, 1); + /// return t * t * (3 - 2 * t); /// Results are undefined if edge0 >= edge1. /// /// @tparam genType Floating-point scalar or vector types. @@ -287,13 +287,13 @@ namespace glm /// @see GLSL smoothstep man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template - genType smoothstep( + GLM_FUNC_DECL genType smoothstep( genType const & edge0, genType const & edge1, genType const & x); template - genType smoothstep( + GLM_FUNC_DECL genType smoothstep( typename genType::value_type const & edge0, typename genType::value_type const & edge1, genType const & x); @@ -311,7 +311,7 @@ namespace glm /// @see GLSL isnan man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template - typename genType::bool_type isnan(genType const & x); + GLM_FUNC_DECL typename genType::bool_type isnan(genType const & x); /// Returns true if x holds a positive infinity or negative /// infinity representation in the underlying implementation's @@ -324,7 +324,7 @@ namespace glm /// @see GLSL isinf man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template - typename genType::bool_type isinf(genType const & x); + GLM_FUNC_DECL typename genType::bool_type isinf(genType const & x); /// Returns a signed integer value representing /// the encoding of a floating-point value. The floatingpoint @@ -336,7 +336,7 @@ namespace glm /// @see GLSL floatBitsToInt man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template - genIType floatBitsToInt(genType const & value); + GLM_FUNC_DECL genIType floatBitsToInt(genType const & value); /// Returns a unsigned integer value representing /// the encoding of a floating-point value. The floatingpoint @@ -348,7 +348,7 @@ namespace glm /// @see GLSL floatBitsToUint man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template - genUType floatBitsToUint(genType const & value); + GLM_FUNC_DECL genUType floatBitsToUint(genType const & value); /// Returns a floating-point value corresponding to a signed /// integer encoding of a floating-point value. @@ -364,7 +364,7 @@ namespace glm /// /// @todo Clarify this declaration, we don't need to actually specify the return type template - genType intBitsToFloat(genIType const & value); + GLM_FUNC_DECL genType intBitsToFloat(genIType const & value); /// Returns a floating-point value corresponding to a /// unsigned integer encoding of a floating-point value. @@ -380,7 +380,7 @@ namespace glm /// /// @todo Clarify this declaration, we don't need to actually specify the return type template - genType uintBitsToFloat(genUType const & value); + GLM_FUNC_DECL genType uintBitsToFloat(genUType const & value); /// Computes and returns a * b + c. /// @@ -389,7 +389,7 @@ namespace glm /// @see GLSL fma man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template - genType fma(genType const & a, genType const & b, genType const & c); + GLM_FUNC_DECL genType fma(genType const & a, genType const & b, genType const & c); /// Splits x into a floating-point significand in the range /// [0.5, 1.0) and an integral exponent of two, such that: @@ -406,7 +406,7 @@ namespace glm /// @see GLSL frexp man page /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template - genType frexp(genType const & x, genIType & exp); + GLM_FUNC_DECL genType frexp(genType const & x, genIType & exp); /// Builds a floating-point number from x and the /// corresponding integral exponent of two in exp, returning: @@ -420,7 +420,7 @@ namespace glm /// @see GLSL ldexp man page; /// @see GLSL 4.20.8 specification, section 8.3 Common Functions template - genType ldexp(genType const & x, genIType const & exp); + GLM_FUNC_DECL genType ldexp(genType const & x, genIType const & exp); /// @} }//namespace glm diff --git a/include/gal/opengl/glm/core/func_common.inl b/include/gal/opengl/glm/core/func_common.inl index 9c1c0470c2..1c0d9df979 100644 --- a/include/gal/opengl/glm/core/func_common.inl +++ b/include/gal/opengl/glm/core/func_common.inl @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights @@ -36,7 +36,7 @@ namespace detail template struct Abs_ { - static genFIType get(genFIType const & x) + GLM_FUNC_QUALIFIER static genFIType get(genFIType const & x) { GLM_STATIC_ASSERT( detail::type::is_float || @@ -49,7 +49,7 @@ namespace detail template struct Abs_ { - static genFIType get(genFIType const & x) + GLM_FUNC_QUALIFIER static genFIType get(genFIType const & x) { GLM_STATIC_ASSERT( detail::type::is_uint, "'abs' only accept floating-point and integer inputs"); @@ -275,7 +275,7 @@ namespace detail //// Only valid if (INT_MIN <= x-y <= INT_MAX) //// min(x,y) //r = y + ((x - y) & ((x - y) >> (sizeof(int) * - //CHAR_BIT – 1))); + //CHAR_BIT - 1))); //// max(x,y) //r = x - ((x - y) & ((x - y) >> (sizeof(int) * //CHAR_BIT - 1))); @@ -420,93 +420,87 @@ namespace detail } // mix - template - GLM_FUNC_QUALIFIER genTypeT mix + template + GLM_FUNC_QUALIFIER genType mix ( - genTypeT const & x, - genTypeT const & y, - genTypeU const & a + genType const & x, + genType const & y, + genType const & a ) { - // It could be a vector too - //GLM_STATIC_ASSERT( - // detail::type::is_float && - // detail::type::is_float); + GLM_STATIC_ASSERT(detail::type::is_float , "'genType' is not floating-point type"); - //return x + a * (y - x); - return genTypeT(genTypeU(x) + a * genTypeU(y - x)); + return x + a * (y - x); } - template - GLM_FUNC_QUALIFIER detail::tvec2 mix + template + GLM_FUNC_QUALIFIER detail::tvec2 mix ( - detail::tvec2 const & x, - detail::tvec2 const & y, - valTypeB const & a + detail::tvec2 const & x, + detail::tvec2 const & y, + valType const & a ) { - return detail::tvec2( - detail::tvec2(x) + a * detail::tvec2(y - x)); + GLM_STATIC_ASSERT(detail::type::is_float , "'genType' is not floating-point type"); + + return x + a * (y - x); } - template - GLM_FUNC_QUALIFIER detail::tvec3 mix + template + GLM_FUNC_QUALIFIER detail::tvec3 mix ( - detail::tvec3 const & x, - detail::tvec3 const & y, - valTypeB const & a + detail::tvec3 const & x, + detail::tvec3 const & y, + valType const & a ) { - return detail::tvec3( - detail::tvec3(x) + a * detail::tvec3(y - x)); + return x + a * (y - x); } - template - GLM_FUNC_QUALIFIER detail::tvec4 mix + template + GLM_FUNC_QUALIFIER detail::tvec4 mix ( - detail::tvec4 const & x, - detail::tvec4 const & y, - valTypeB const & a + detail::tvec4 const & x, + detail::tvec4 const & y, + valType const & a ) { - return detail::tvec4( - detail::tvec4(x) + a * detail::tvec4(y - x)); + return x + a * (y - x); } - template - GLM_FUNC_QUALIFIER detail::tvec2 mix + template + GLM_FUNC_QUALIFIER detail::tvec2 mix ( - detail::tvec2 const & x, - detail::tvec2 const & y, - detail::tvec2 const & a + detail::tvec2 const & x, + detail::tvec2 const & y, + detail::tvec2 const & a ) { - return detail::tvec2( - detail::tvec2(x) + a * detail::tvec2(y - x)); + return x + a * (y - x); } - template - GLM_FUNC_QUALIFIER detail::tvec3 mix + template + GLM_FUNC_QUALIFIER detail::tvec3 mix ( - detail::tvec3 const & x, - detail::tvec3 const & y, - detail::tvec3 const & a + detail::tvec3 const & x, + detail::tvec3 const & y, + detail::tvec3 const & a ) { - return detail::tvec3( - detail::tvec3(x) + a * detail::tvec3(y - x)); + GLM_STATIC_ASSERT(detail::type::is_float , "'genType' is not floating-point type"); + + return x + a * (y - x); } - template - GLM_FUNC_QUALIFIER detail::tvec4 mix + template + GLM_FUNC_QUALIFIER detail::tvec4 mix ( - detail::tvec4 const & x, - detail::tvec4 const & y, - detail::tvec4 const & a + detail::tvec4 const & x, + detail::tvec4 const & y, + detail::tvec4 const & a ) { - return detail::tvec4( - detail::tvec4(x) + a * detail::tvec4(y - x)); + return x + a * (y - x); } //template @@ -525,15 +519,63 @@ namespace detail // return x + a * (y - x); //} - template - GLM_FUNC_QUALIFIER genType mix + template <> + GLM_FUNC_QUALIFIER float mix ( - genType const & x, - genType const & y, + float const & x, + float const & y, bool const & a ) { - GLM_STATIC_ASSERT(detail::type::is_float, "'mix' only accept floating-point inputs"); + return a ? y : x; + } + + template <> + GLM_FUNC_QUALIFIER double mix + ( + double const & x, + double const & y, + bool const & a + ) + { + return a ? y : x; + } + + template + GLM_FUNC_QUALIFIER detail::tvec2 mix + ( + detail::tvec2 const & x, + detail::tvec2 const & y, + bool a + ) + { + GLM_STATIC_ASSERT(detail::type::is_float, "'mix' only accept floating-point inputs"); + + return a ? y : x; + } + + template + GLM_FUNC_QUALIFIER detail::tvec3 mix + ( + detail::tvec3 const & x, + detail::tvec3 const & y, + bool a + ) + { + GLM_STATIC_ASSERT(detail::type::is_float, "'mix' only accept floating-point inputs"); + + return a ? y : x; + } + + template + GLM_FUNC_QUALIFIER detail::tvec4 mix + ( + detail::tvec4 const & x, + detail::tvec4 const & y, + bool a + ) + { + GLM_STATIC_ASSERT(detail::type::is_float, "'mix' only accept floating-point inputs"); return a ? y : x; } @@ -552,8 +594,7 @@ namespace detail for ( typename detail::tvec2::size_type i = 0; - i < detail::tvec2::value_size(); - ++i + i < x.length(); ++i ) { result[i] = a[i] ? y[i] : x[i]; @@ -575,8 +616,7 @@ namespace detail for ( typename detail::tvec3::size_type i = 0; - i < detail::tvec3::value_size(); - ++i + i < x.length(); ++i ) { result[i] = a[i] ? y[i] : x[i]; @@ -598,8 +638,7 @@ namespace detail for ( typename detail::tvec4::size_type i = 0; - i < detail::tvec4::value_size(); - ++i + i < x.length(); ++i ) { result[i] = a[i] ? y[i] : x[i]; @@ -803,17 +842,19 @@ namespace detail { GLM_STATIC_ASSERT(detail::type::is_float, "'isnan' only accept floating-point inputs"); -# if(GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_INTEL)) +# if(GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_INTEL)) return _isnan(x) != 0; -# elif(GLM_COMPILER & GLM_COMPILER_GCC) +# elif(GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG)) # if(GLM_PLATFORM & GLM_PLATFORM_ANDROID) return _isnan(x) != 0; # else return std::isnan(x); # endif -# else +# elif(GLM_COMPILER & GLM_COMPILER_CUDA) + return isnan(x) != 0; +# else return std::isnan(x); -# endif +# endif } template @@ -858,32 +899,20 @@ namespace detail { GLM_STATIC_ASSERT(detail::type::is_float, "'isinf' only accept floating-point inputs"); -# if(GLM_COMPILER & (GLM_COMPILER_INTEL | GLM_COMPILER_VC)) +# if(GLM_COMPILER & (GLM_COMPILER_INTEL | GLM_COMPILER_VC)) return _fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF; -# elif(GLM_COMPILER & GLM_COMPILER_GCC) +# elif(GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG)) # if(GLM_PLATFORM & GLM_PLATFORM_ANDROID) return _isinf(x) != 0; # else return std::isinf(x); # endif -# else +# elif(GLM_COMPILER & GLM_COMPILER_CUDA) + // http://developer.download.nvidia.com/compute/cuda/4_2/rel/toolkit/docs/online/group__CUDA__MATH__DOUBLE_g13431dd2b40b51f9139cbb7f50c18fab.html#g13431dd2b40b51f9139cbb7f50c18fab + return isinf(double(x)) != 0; +# else return std::isinf(x); -# endif -/* -# if(GLM_COMPILER & GLM_COMPILER_VC) - return _fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF; -# elif(GLM_COMPILER & GLM_COMPILER_GCC) -# if(GLM_PLATFORM & GLM_PLATFORM_ANDROID) - return _isinf(x) != 0; -# else - return std::isinf(x); -# endif -# elif(GLM_COMPILER & GLM_COMPILER_INTEL) - return isinf(x) != 0; -# else - return std::isinf(x); -# endif -*/ +# endif } template diff --git a/include/gal/opengl/glm/core/func_exponential.hpp b/include/gal/opengl/glm/core/func_exponential.hpp index 557ac175d2..dc76fcbb93 100644 --- a/include/gal/opengl/glm/core/func_exponential.hpp +++ b/include/gal/opengl/glm/core/func_exponential.hpp @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights @@ -41,16 +41,16 @@ namespace glm /// @addtogroup core_func_exponential /// @{ - /// Returns x raised to the y power. + /// Returns 'base' raised to the power 'exponent'. /// - /// @param x pow function is defined for input values of x defined in the range (inf-, inf+) in the limit of the type precision. - /// @param y + /// @param base Floating point value. pow function is defined for input values of x defined in the range (inf-, inf+) in the limit of the type precision. + /// @param exponent Floating point value representing the 'exponent'. /// @tparam genType Floating-point scalar or vector types. /// /// @see GLSL pow man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions template - genType pow(genType const & x, genType const & y); + GLM_FUNC_DECL genType pow(genType const & base, genType const & exponent); /// Returns the natural exponentiation of x, i.e., e^x. /// @@ -60,7 +60,7 @@ namespace glm /// @see GLSL exp man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions template - genType exp(genType const & x); + GLM_FUNC_DECL genType exp(genType const & x); /// Returns the natural logarithm of x, i.e., /// returns the value y which satisfies the equation x = e^y. @@ -72,7 +72,7 @@ namespace glm /// @see GLSL log man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions template - genType log(genType const & x); + GLM_FUNC_DECL genType log(genType const & x); /// Returns 2 raised to the x power. /// @@ -82,7 +82,7 @@ namespace glm /// @see GLSL exp2 man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions template - genType exp2(genType const & x); + GLM_FUNC_DECL genType exp2(genType const & x); /// Returns the base 2 log of x, i.e., returns the value y, /// which satisfies the equation x = 2 ^ y. @@ -93,7 +93,7 @@ namespace glm /// @see GLSL log2 man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions template - genType log2(genType const & x); + GLM_FUNC_DECL genType log2(genType const & x); /// Returns the positive square root of x. /// @@ -103,7 +103,7 @@ namespace glm /// @see GLSL sqrt man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions template - genType sqrt(genType const & x); + GLM_FUNC_DECL genType sqrt(genType const & x); /// Returns the reciprocal of the positive square root of x. /// @@ -113,7 +113,7 @@ namespace glm /// @see GLSL inversesqrt man page /// @see GLSL 4.20.8 specification, section 8.2 Exponential Functions template - genType inversesqrt(genType const & x); + GLM_FUNC_DECL genType inversesqrt(genType const & x); /// @} }//namespace glm diff --git a/include/gal/opengl/glm/core/func_exponential.inl b/include/gal/opengl/glm/core/func_exponential.inl index 6ae709c6de..1b08786df6 100644 --- a/include/gal/opengl/glm/core/func_exponential.inl +++ b/include/gal/opengl/glm/core/func_exponential.inl @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights @@ -146,6 +146,7 @@ namespace _detail ) { GLM_STATIC_ASSERT(detail::type::is_float, "'inversesqrt' only accept floating-point input"); + assert(x > genType(0)); return genType(1) / ::std::sqrt(x); } diff --git a/include/gal/opengl/glm/core/func_geometric.hpp b/include/gal/opengl/glm/core/func_geometric.hpp index 1c92e1b88b..c221084f14 100644 --- a/include/gal/opengl/glm/core/func_geometric.hpp +++ b/include/gal/opengl/glm/core/func_geometric.hpp @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights @@ -48,7 +48,7 @@ namespace glm /// @see GLSL length man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template - typename genType::value_type length( + GLM_FUNC_DECL typename genType::value_type length( genType const & x); /// Returns the distance betwwen p0 and p1, i.e., length(p0 - p1). @@ -58,7 +58,7 @@ namespace glm /// @see GLSL distance man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template - typename genType::value_type distance( + GLM_FUNC_DECL typename genType::value_type distance( genType const & p0, genType const & p1); @@ -69,7 +69,7 @@ namespace glm /// @see GLSL dot man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template - typename genType::value_type dot( + GLM_FUNC_DECL typename genType::value_type dot( genType const & x, genType const & y); @@ -80,7 +80,7 @@ namespace glm /// @see GLSL cross man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template - detail::tvec3 cross( + GLM_FUNC_DECL detail::tvec3 cross( detail::tvec3 const & x, detail::tvec3 const & y); @@ -89,7 +89,7 @@ namespace glm /// @see GLSL normalize man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template - genType normalize( + GLM_FUNC_DECL genType normalize( genType const & x); /// If dot(Nref, I) < 0.0, return N, otherwise, return -N. @@ -99,7 +99,7 @@ namespace glm /// @see GLSL faceforward man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template - genType faceforward( + GLM_FUNC_DECL genType faceforward( genType const & N, genType const & I, genType const & Nref); @@ -112,7 +112,7 @@ namespace glm /// @see GLSL reflect man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template - genType reflect( + GLM_FUNC_DECL genType reflect( genType const & I, genType const & N); @@ -125,7 +125,7 @@ namespace glm /// @see GLSL refract man page /// @see GLSL 4.20.8 specification, section 8.5 Geometric Functions template - genType refract( + GLM_FUNC_DECL genType refract( genType const & I, genType const & N, typename genType::value_type const & eta); diff --git a/include/gal/opengl/glm/core/func_geometric.inl b/include/gal/opengl/glm/core/func_geometric.inl index 1923d05d1b..259a0ffdf9 100644 --- a/include/gal/opengl/glm/core/func_geometric.inl +++ b/include/gal/opengl/glm/core/func_geometric.inl @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights @@ -132,7 +132,6 @@ namespace glm ( genType const & x, genType const & y - ) { GLM_STATIC_ASSERT(detail::type::is_float, "'dot' only accept floating-point inputs"); @@ -271,7 +270,7 @@ namespace glm // reflect template - genType reflect + GLM_FUNC_QUALIFIER genType reflect ( genType const & I, genType const & N diff --git a/include/gal/opengl/glm/core/func_integer.hpp b/include/gal/opengl/glm/core/func_integer.hpp index affbcd8fa5..df9a401591 100644 --- a/include/gal/opengl/glm/core/func_integer.hpp +++ b/include/gal/opengl/glm/core/func_integer.hpp @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights @@ -52,7 +52,7 @@ namespace glm /// @see GLSL uaddCarry man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template - genUType uaddCarry( + GLM_FUNC_DECL genUType uaddCarry( genUType const & x, genUType const & y, genUType & carry); @@ -66,7 +66,7 @@ namespace glm /// @see GLSL usubBorrow man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template - genUType usubBorrow( + GLM_FUNC_DECL genUType usubBorrow( genUType const & x, genUType const & y, genUType & borrow); @@ -80,7 +80,7 @@ namespace glm /// @see GLSL umulExtended man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template - void umulExtended( + GLM_FUNC_DECL void umulExtended( genUType const & x, genUType const & y, genUType & msb, @@ -95,7 +95,7 @@ namespace glm /// @see GLSL imulExtended man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template - void imulExtended( + GLM_FUNC_DECL void imulExtended( genIType const & x, genIType const & y, genIType & msb, @@ -105,7 +105,7 @@ namespace glm /// returning them in the least significant bits of the result. /// For unsigned data types, the most significant bits of the /// result will be set to zero. For signed data types, the - /// most significant bits will be set to the value of bit offset + base – 1. + /// most significant bits will be set to the value of bit offset + base - 1. /// /// If bits is zero, the result will be zero. The result will be /// undefined if offset or bits is negative, or if the sum of @@ -117,7 +117,7 @@ namespace glm /// @see GLSL bitfieldExtract man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template - genIUType bitfieldExtract( + GLM_FUNC_DECL genIUType bitfieldExtract( genIUType const & Value, int const & Offset, int const & Bits); @@ -125,7 +125,7 @@ namespace glm /// Returns the insertion the bits least-significant bits of insert into base. /// /// The result will have bits [offset, offset + bits - 1] taken - /// from bits [0, bits – 1] of insert, and all other bits taken + /// from bits [0, bits - 1] of insert, and all other bits taken /// directly from the corresponding bits of base. If bits is /// zero, the result will simply be base. The result will be /// undefined if offset or bits is negative, or if the sum of @@ -137,7 +137,7 @@ namespace glm /// @see GLSL bitfieldInsert man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template - genIUType bitfieldInsert( + GLM_FUNC_DECL genIUType bitfieldInsert( genIUType const & Base, genIUType const & Insert, int const & Offset, @@ -152,7 +152,7 @@ namespace glm /// @see GLSL bitfieldReverse man page /// @see GLSL 4.20.8 specification, section 8.8 Integer Functions template - genIUType bitfieldReverse(genIUType const & Value); + GLM_FUNC_DECL genIUType bitfieldReverse(genIUType const & Value); /// Returns the number of bits set to 1 in the binary representation of value. /// @@ -163,7 +163,7 @@ namespace glm /// /// @todo Clarify the declaration to specify that scalars are suported. template class genIUType> - typename genIUType::signed_type bitCount(genIUType const & Value); + GLM_FUNC_DECL typename genIUType::signed_type bitCount(genIUType const & Value); /// Returns the bit number of the least significant bit set to /// 1 in the binary representation of value. @@ -176,7 +176,7 @@ namespace glm /// /// @todo Clarify the declaration to specify that scalars are suported. template class genIUType> - typename genIUType::signed_type findLSB(genIUType const & Value); + GLM_FUNC_DECL typename genIUType::signed_type findLSB(genIUType const & Value); /// Returns the bit number of the most significant bit in the binary representation of value. /// For positive integers, the result will be the bit number of the most significant bit set to 1. @@ -190,7 +190,7 @@ namespace glm /// /// @todo Clarify the declaration to specify that scalars are suported. template class genIUType> - typename genIUType::signed_type findMSB(genIUType const & Value); + GLM_FUNC_DECL typename genIUType::signed_type findMSB(genIUType const & Value); /// @} }//namespace glm diff --git a/include/gal/opengl/glm/core/func_integer.inl b/include/gal/opengl/glm/core/func_integer.inl index ae7bf8af36..ad8b1fe83c 100644 --- a/include/gal/opengl/glm/core/func_integer.inl +++ b/include/gal/opengl/glm/core/func_integer.inl @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights @@ -26,10 +26,12 @@ /// @author Christophe Riccio /////////////////////////////////////////////////////////////////////////////////// +#if(GLM_ARCH != GLM_ARCH_PURE) #if(GLM_COMPILER & GLM_COMPILER_VC) -#include -#pragma intrinsic(_BitScanReverse) -#endif +# include +# pragma intrinsic(_BitScanReverse) +#endif//(GLM_COMPILER & GLM_COMPILER_VC) +#endif//(GLM_ARCH != GLM_ARCH_PURE) namespace glm { @@ -103,7 +105,7 @@ namespace glm if(x > y) return genUType(detail::highp_int_t(x) - detail::highp_int_t(y)); else - return genUType(detail::highp_int_t(1) << detail::highp_int_t(32) + detail::highp_int_t(x) - detail::highp_int_t(y)); + return genUType((detail::highp_int_t(1) << detail::highp_int_t(32)) + detail::highp_int_t(x) - detail::highp_int_t(y)); } template @@ -521,7 +523,6 @@ namespace glm } // findMSB -/* #if((GLM_ARCH != GLM_ARCH_PURE) && (GLM_COMPILER & GLM_COMPILER_VC)) template @@ -538,7 +539,7 @@ namespace glm _BitScanReverse(&Result, Value); return int(Result); } - +/* // __builtin_clz seems to be buggy as it crasks for some values, from 0x00200000 to 80000000 #elif((GLM_ARCH != GLM_ARCH_PURE) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC40)) @@ -560,8 +561,9 @@ namespace glm // return 31 - __builtin_clzl(Value); } -#else */ +#else + /* SSE implementation idea __m128i const Zero = _mm_set_epi32( 0, 0, 0, 0); @@ -606,7 +608,7 @@ namespace glm return MostSignificantBit; } } -//#endif//(GLM_COMPILER) +#endif//(GLM_COMPILER) template GLM_FUNC_QUALIFIER detail::tvec2 findMSB diff --git a/include/gal/opengl/glm/core/func_matrix.hpp b/include/gal/opengl/glm/core/func_matrix.hpp index ac1fda8482..3c92cbbaba 100644 --- a/include/gal/opengl/glm/core/func_matrix.hpp +++ b/include/gal/opengl/glm/core/func_matrix.hpp @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights @@ -53,7 +53,7 @@ namespace glm /// @see GLSL matrixCompMult man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions template - matType matrixCompMult( + GLM_FUNC_DECL matType matrixCompMult( matType const & x, matType const & y); @@ -68,7 +68,7 @@ namespace glm /// /// @todo Clarify the declaration to specify that matType doesn't have to be provided when used. template - matType outerProduct( + GLM_FUNC_DECL matType outerProduct( vecType const & c, vecType const & r); @@ -79,7 +79,7 @@ namespace glm /// @see GLSL transpose man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions template - typename matType::transpose_type transpose( + GLM_FUNC_DECL typename matType::transpose_type transpose( matType const & x); /// Return the determinant of a mat2 matrix. @@ -89,7 +89,7 @@ namespace glm /// @see GLSL determinant man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions template - typename detail::tmat2x2::value_type determinant( + GLM_FUNC_DECL typename detail::tmat2x2::value_type determinant( detail::tmat2x2 const & m); /// Return the determinant of a mat3 matrix. @@ -99,7 +99,7 @@ namespace glm /// @see GLSL determinant man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions template - typename detail::tmat3x3::value_type determinant( + GLM_FUNC_DECL typename detail::tmat3x3::value_type determinant( detail::tmat3x3 const & m); /// Return the determinant of a mat4 matrix. @@ -109,7 +109,7 @@ namespace glm /// @see GLSL determinant man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions template - typename detail::tmat4x4::value_type determinant( + GLM_FUNC_DECL typename detail::tmat4x4::value_type determinant( detail::tmat4x4 const & m); /// Return the inverse of a mat2 matrix. @@ -119,7 +119,7 @@ namespace glm /// @see GLSL inverse man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions template - detail::tmat2x2 inverse( + GLM_FUNC_DECL detail::tmat2x2 inverse( detail::tmat2x2 const & m); /// Return the inverse of a mat3 matrix. @@ -129,7 +129,7 @@ namespace glm /// @see GLSL inverse man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions template - detail::tmat3x3 inverse( + GLM_FUNC_DECL detail::tmat3x3 inverse( detail::tmat3x3 const & m); /// Return the inverse of a mat4 matrix. @@ -139,7 +139,7 @@ namespace glm /// @see GLSL inverse man page /// @see GLSL 4.20.8 specification, section 8.6 Matrix Functions template - detail::tmat4x4 inverse( + GLM_FUNC_DECL detail::tmat4x4 inverse( detail::tmat4x4 const & m); /// @} diff --git a/include/gal/opengl/glm/core/func_matrix.inl b/include/gal/opengl/glm/core/func_matrix.inl index 3b07b74b1d..d89d5d4b16 100644 --- a/include/gal/opengl/glm/core/func_matrix.inl +++ b/include/gal/opengl/glm/core/func_matrix.inl @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights diff --git a/include/gal/opengl/glm/core/func_noise.hpp b/include/gal/opengl/glm/core/func_noise.hpp index 369f56de6f..3e5f874187 100644 --- a/include/gal/opengl/glm/core/func_noise.hpp +++ b/include/gal/opengl/glm/core/func_noise.hpp @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights @@ -50,7 +50,7 @@ namespace glm /// @see GLSL noise1 man page /// @see GLSL 4.20.8 specification, section 8.13 Noise Functions template - typename genType::value_type noise1(genType const & x); + GLM_FUNC_DECL typename genType::value_type noise1(genType const & x); /// Returns a 2D noise value based on the input value x. /// @@ -59,7 +59,7 @@ namespace glm /// @see GLSL noise2 man page /// @see GLSL 4.20.8 specification, section 8.13 Noise Functions template - detail::tvec2 noise2(genType const & x); + GLM_FUNC_DECL detail::tvec2 noise2(genType const & x); /// Returns a 3D noise value based on the input value x. /// @@ -68,7 +68,7 @@ namespace glm /// @see GLSL noise3 man page /// @see GLSL 4.20.8 specification, section 8.13 Noise Functions template - detail::tvec3 noise3(genType const & x); + GLM_FUNC_DECL detail::tvec3 noise3(genType const & x); /// Returns a 4D noise value based on the input value x. /// @@ -77,7 +77,7 @@ namespace glm /// @see GLSL noise4 man page /// @see GLSL 4.20.8 specification, section 8.13 Noise Functions template - detail::tvec4 noise4(genType const & x); + GLM_FUNC_DECL detail::tvec4 noise4(genType const & x); /// @} }//namespace glm diff --git a/include/gal/opengl/glm/core/func_noise.inl b/include/gal/opengl/glm/core/func_noise.inl index a53ba5a75b..68a19333f1 100644 --- a/include/gal/opengl/glm/core/func_noise.inl +++ b/include/gal/opengl/glm/core/func_noise.inl @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights diff --git a/include/gal/opengl/glm/core/func_packing.hpp b/include/gal/opengl/glm/core/func_packing.hpp index e4f26dcbf5..b4312e12b4 100644 --- a/include/gal/opengl/glm/core/func_packing.hpp +++ b/include/gal/opengl/glm/core/func_packing.hpp @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights @@ -52,7 +52,7 @@ namespace glm //! /// @see GLSL packUnorm2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions - detail::uint32 packUnorm2x16(detail::tvec2 const & v); + GLM_FUNC_DECL detail::uint32 packUnorm2x16(detail::tvec2 const & v); //! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. //! Then, the results are packed into the returned 32-bit unsigned integer. @@ -65,7 +65,7 @@ namespace glm //! /// @see GLSL packSnorm2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions - detail::uint32 packSnorm2x16(detail::tvec2 const & v); + GLM_FUNC_DECL detail::uint32 packSnorm2x16(detail::tvec2 const & v); //! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. //! Then, the results are packed into the returned 32-bit unsigned integer. @@ -78,7 +78,7 @@ namespace glm //! /// @see GLSL packUnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions - detail::uint32 packUnorm4x8(detail::tvec4 const & v); + GLM_FUNC_DECL detail::uint32 packUnorm4x8(detail::tvec4 const & v); //! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. //! Then, the results are packed into the returned 32-bit unsigned integer. @@ -91,7 +91,7 @@ namespace glm //! /// @see GLSL packSnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions - detail::uint32 packSnorm4x8(detail::tvec4 const & v); + GLM_FUNC_DECL detail::uint32 packSnorm4x8(detail::tvec4 const & v); //! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. //! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector. @@ -104,7 +104,7 @@ namespace glm //! /// @see GLSL unpackUnorm2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions - detail::tvec2 unpackUnorm2x16(detail::uint32 const & p); + GLM_FUNC_DECL detail::tvec2 unpackUnorm2x16(detail::uint32 const & p); //! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. //! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector. @@ -117,7 +117,7 @@ namespace glm //! /// @see GLSL unpackSnorm2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions - detail::tvec2 unpackSnorm2x16(detail::uint32 const & p); + GLM_FUNC_DECL detail::tvec2 unpackSnorm2x16(detail::uint32 const & p); /// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. /// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector. @@ -130,7 +130,7 @@ namespace glm /// /// @see GLSL unpackUnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions - detail::tvec4 unpackUnorm4x8(detail::uint32 const & p); + GLM_FUNC_DECL detail::tvec4 unpackUnorm4x8(detail::uint32 const & p); /// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. /// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector. @@ -143,7 +143,7 @@ namespace glm /// /// @see GLSL unpackSnorm4x8 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions - detail::tvec4 unpackSnorm4x8(detail::uint32 const & p); + GLM_FUNC_DECL detail::tvec4 unpackSnorm4x8(detail::uint32 const & p); /// Returns a double-precision 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. @@ -153,7 +153,7 @@ namespace glm /// /// @see GLSL packDouble2x32 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions - double packDouble2x32(detail::tvec2 const & v); + GLM_FUNC_DECL double packDouble2x32(detail::tvec2 const & v); /// Returns a two-component unsigned integer vector representation of v. /// The bit-level representation of v is preserved. @@ -162,7 +162,7 @@ namespace glm /// /// @see GLSL unpackDouble2x32 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions - detail::tvec2 unpackDouble2x32(double const & v); + GLM_FUNC_DECL detail::tvec2 unpackDouble2x32(double const & v); /// Returns an unsigned integer obtained by converting the components of a two-component floating-point vector /// to the 16-bit floating-point representation found in the OpenGL Specification, @@ -172,7 +172,7 @@ namespace glm /// /// @see GLSL packHalf2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions - uint packHalf2x16(vec2 const & v); + GLM_FUNC_DECL uint packHalf2x16(vec2 const & v); /// Returns a two-component floating-point vector with components obtained by unpacking a 32-bit unsigned integer into a pair of 16-bit values, /// interpreting those values as 16-bit floating-point numbers according to the OpenGL Specification, @@ -182,7 +182,7 @@ namespace glm /// /// @see GLSL unpackHalf2x16 man page /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions - vec2 unpackHalf2x16(uint const & v); + GLM_FUNC_DECL vec2 unpackHalf2x16(uint const & v); /// @} }//namespace glm diff --git a/include/gal/opengl/glm/core/func_packing.inl b/include/gal/opengl/glm/core/func_packing.inl index 27197151bb..e10e161840 100644 --- a/include/gal/opengl/glm/core/func_packing.inl +++ b/include/gal/opengl/glm/core/func_packing.inl @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights @@ -136,12 +136,42 @@ namespace glm GLM_FUNC_QUALIFIER double packDouble2x32(detail::tvec2 const & v) { - return *(double*)&v; + struct uint32_pair + { + detail::uint32 x; + detail::uint32 y; + }; + + union helper + { + uint32_pair input; + double output; + } Helper; + + Helper.input.x = v.x; + Helper.input.y = v.y; + + return Helper.output; + //return *(double*)&v; } GLM_FUNC_QUALIFIER detail::tvec2 unpackDouble2x32(double const & v) { - return *(detail::tvec2*)&v; + struct uint32_pair + { + detail::uint32 x; + detail::uint32 y; + }; + + union helper + { + double input; + uint32_pair output; + } Helper; + + Helper.input = v; + + return detail::tvec2(Helper.output.x, Helper.output.y); } GLM_FUNC_QUALIFIER uint packHalf2x16(detail::tvec2 const & v) @@ -157,7 +187,7 @@ namespace glm Pack.orig.a = detail::toFloat16(v.x); Pack.orig.b = detail::toFloat16(v.y); - return *(uint*)&Pack; + return Pack.other; } GLM_FUNC_QUALIFIER vec2 unpackHalf2x16(uint const & v) diff --git a/include/gal/opengl/glm/core/func_trigonometric.hpp b/include/gal/opengl/glm/core/func_trigonometric.hpp index ccb7f9ea6d..9954d9cea6 100644 --- a/include/gal/opengl/glm/core/func_trigonometric.hpp +++ b/include/gal/opengl/glm/core/func_trigonometric.hpp @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights @@ -52,7 +52,7 @@ namespace glm /// @see GLSL radians man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template - genType radians(genType const & degrees); + GLM_FUNC_DECL genType radians(genType const & degrees); /// Converts radians to degrees and returns the result. /// @@ -61,7 +61,7 @@ namespace glm /// @see GLSL degrees man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template - genType degrees(genType const & radians); + GLM_FUNC_DECL genType degrees(genType const & radians); /// The standard trigonometric sine function. /// The values returned by this function will range from [-1, 1]. @@ -71,7 +71,7 @@ namespace glm /// @see GLSL sin man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template - genType sin(genType const & angle); + GLM_FUNC_DECL genType sin(genType const & angle); /// The standard trigonometric cosine function. /// The values returned by this function will range from [-1, 1]. @@ -81,7 +81,7 @@ namespace glm /// @see GLSL cos man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template - genType cos(genType const & angle); + GLM_FUNC_DECL genType cos(genType const & angle); /// The standard trigonometric tangent function. /// @@ -90,7 +90,7 @@ namespace glm /// @see GLSL tan man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template - genType tan(genType const & angle); + GLM_FUNC_DECL genType tan(genType const & angle); /// Arc sine. Returns an angle whose sine is x. /// The range of values returned by this function is [-PI/2, PI/2]. @@ -101,7 +101,7 @@ namespace glm /// @see GLSL asin man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template - genType asin(genType const & x); + GLM_FUNC_DECL genType asin(genType const & x); /// Arc cosine. Returns an angle whose sine is x. /// The range of values returned by this function is [0, PI]. @@ -112,7 +112,7 @@ namespace glm /// @see GLSL acos man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template - genType acos(genType const & x); + GLM_FUNC_DECL genType acos(genType const & x); /// Arc tangent. Returns an angle whose tangent is y/x. /// The signs of x and y are used to determine what @@ -125,7 +125,7 @@ namespace glm /// @see GLSL atan man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template - genType atan(genType const & y, genType const & x); + GLM_FUNC_DECL genType atan(genType const & y, genType const & x); /// Arc tangent. Returns an angle whose tangent is y_over_x. /// The range of values returned by this function is [-PI/2, PI/2]. @@ -135,7 +135,7 @@ namespace glm /// @see GLSL atan man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template - genType atan(genType const & y_over_x); + GLM_FUNC_DECL genType atan(genType const & y_over_x); /// Returns the hyperbolic sine function, (exp(x) - exp(-x)) / 2 /// @@ -144,7 +144,7 @@ namespace glm /// @see GLSL sinh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template - genType sinh(genType const & angle); + GLM_FUNC_DECL genType sinh(genType const & angle); /// Returns the hyperbolic cosine function, (exp(x) + exp(-x)) / 2 /// @@ -153,7 +153,7 @@ namespace glm /// @see GLSL cosh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template - genType cosh(genType const & angle); + GLM_FUNC_DECL genType cosh(genType const & angle); /// Returns the hyperbolic tangent function, sinh(angle) / cosh(angle) /// @@ -162,7 +162,7 @@ namespace glm /// @see GLSL tanh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template - genType tanh(genType const & angle); + GLM_FUNC_DECL genType tanh(genType const & angle); /// Arc hyperbolic sine; returns the inverse of sinh. /// @@ -171,7 +171,7 @@ namespace glm /// @see GLSL asinh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template - genType asinh(genType const & x); + GLM_FUNC_DECL genType asinh(genType const & x); /// Arc hyperbolic cosine; returns the non-negative inverse /// of cosh. Results are undefined if x < 1. @@ -181,7 +181,7 @@ namespace glm /// @see GLSL acosh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template - genType acosh(genType const & x); + GLM_FUNC_DECL genType acosh(genType const & x); /// Arc hyperbolic tangent; returns the inverse of tanh. /// Results are undefined if abs(x) >= 1. @@ -191,7 +191,7 @@ namespace glm /// @see GLSL atanh man page /// @see GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions template - genType atanh(genType const & x); + GLM_FUNC_DECL genType atanh(genType const & x); /// @} }//namespace glm diff --git a/include/gal/opengl/glm/core/func_trigonometric.inl b/include/gal/opengl/glm/core/func_trigonometric.inl index 240cdafca0..bd59cd73d4 100644 --- a/include/gal/opengl/glm/core/func_trigonometric.inl +++ b/include/gal/opengl/glm/core/func_trigonometric.inl @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights diff --git a/include/gal/opengl/glm/core/func_vector_relational.hpp b/include/gal/opengl/glm/core/func_vector_relational.hpp index 7b5a7cd080..4ffe14eab7 100644 --- a/include/gal/opengl/glm/core/func_vector_relational.hpp +++ b/include/gal/opengl/glm/core/func_vector_relational.hpp @@ -1,7 +1,7 @@ /////////////////////////////////////////////////////////////////////////////////// /// OpenGL Mathematics (glm.g-truc.net) /// -/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net) +/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) /// Permission is hereby granted, free of charge, to any person obtaining a copy /// of this software and associated documentation files (the "Software"), to deal /// in the Software without restriction, including without limitation the rights @@ -55,7 +55,7 @@ namespace glm /// @see GLSL lessThan man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template - typename vecType::bool_type lessThan(vecType const & x, vecType const & y); + GLM_FUNC_DECL typename vecType::bool_type lessThan(vecType const & x, vecType const & y); /// Returns the component-wise comparison of result x <= y. /// @@ -64,7 +64,7 @@ namespace glm /// @see GLSL lessThanEqual man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template - typename vecType::bool_type lessThanEqual(vecType const & x, vecType const & y); + GLM_FUNC_DECL typename vecType::bool_type lessThanEqual(vecType const & x, vecType const & y); /// Returns the component-wise comparison of result x > y. /// @@ -73,7 +73,7 @@ namespace glm /// @see GLSL greaterThan man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template - typename vecType::bool_type greaterThan(vecType const & x, vecType const & y); + GLM_FUNC_DECL typename vecType::bool_type greaterThan(vecType const & x, vecType const & y); /// Returns the component-wise comparison of result x >= y. /// @@ -82,7 +82,7 @@ namespace glm /// @see GLSL greaterThanEqual man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template - typename vecType::bool_type greaterThanEqual(vecType const & x, vecType const & y); + GLM_FUNC_DECL typename vecType::bool_type greaterThanEqual(vecType const & x, vecType const & y); /// Returns the component-wise comparison of result x == y. /// @@ -91,7 +91,7 @@ namespace glm /// @see GLSL equal man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template - typename vecType::bool_type equal(vecType const & x, vecType const & y); + GLM_FUNC_DECL typename vecType::bool_type equal(vecType const & x, vecType const & y); /// Returns the component-wise comparison of result x != y. /// @@ -100,7 +100,7 @@ namespace glm /// @see GLSL notEqual man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template - typename vecType::bool_type notEqual(vecType const & x, vecType const & y); + GLM_FUNC_DECL typename vecType::bool_type notEqual(vecType const & x, vecType const & y); /// Returns true if any component of x is true. /// @@ -109,7 +109,7 @@ namespace glm /// @see GLSL any man page /// @see GLSL 4.20.8 specification, section 8.7 Vector Relational Functions template