mirror/glm
1
0
Fork 0
mirror of https://github.com/g-truc/glm.git synced 2024-11-25 18:04:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'constexpr' of https://github.com/RohacekD/glm into constexpr

Browse Source
This commit is contained in:
Christophe 2023-12-21 19:25:04 +01:00
commit d487f1839f
14 changed files with 48 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
glm/common.hpp
View File

@ -51,7 +51,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sign.xml">GLSL sign man page</a> /// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sign.xml">GLSL sign man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a> /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_DECL vec<L, T, Q> sign(vec<L, T, Q> const& x); GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> sign(vec<L, T, Q> const& x);
/// Returns a value equal to the nearest integer that is less then or equal to x. /// Returns a value equal to the nearest integer that is less then or equal to x.
/// ///
@ -306,13 +306,13 @@ namespace glm
/// glm::vec4 u = glm::mix(g, h, r); // Interpolations can be perform per component with a vector for the last parameter. /// glm::vec4 u = glm::mix(g, h, r); // Interpolations can be perform per component with a vector for the last parameter.
/// @endcode /// @endcode
template<typename genTypeT, typename genTypeU> template<typename genTypeT, typename genTypeU>
GLM_FUNC_DECL genTypeT mix(genTypeT x, genTypeT y, genTypeU a); GLM_FUNC_DECL GLM_CONSTEXPR genTypeT mix(genTypeT x, genTypeT y, genTypeU a);
template<length_t L, typename T, typename U, qualifier Q> template<length_t L, typename T, typename U, qualifier Q>
GLM_FUNC_DECL vec<L, T, Q> mix(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, U, Q> const& a); GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> mix(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, U, Q> const& a);
template<length_t L, typename T, typename U, qualifier Q> template<length_t L, typename T, typename U, qualifier Q>
GLM_FUNC_DECL vec<L, T, Q> mix(vec<L, T, Q> const& x, vec<L, T, Q> const& y, U a); GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, Q> mix(vec<L, T, Q> const& x, vec<L, T, Q> const& y, U a);
/// Returns 0.0 if x < edge, otherwise it returns 1.0 for each component of a genType. /// Returns 0.0 if x < edge, otherwise it returns 1.0 for each component of a genType.
/// ///

26
glm/detail/func_common.inl
View File

@ -80,7 +80,7 @@ namespace detail
template<length_t L, typename T, typename U, qualifier Q, bool Aligned> template<length_t L, typename T, typename U, qualifier Q, bool Aligned>
struct compute_mix_vector struct compute_mix_vector
{ {
GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, U, Q> const& a) GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, U, Q> const& a)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a"); GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
@ -91,7 +91,7 @@ namespace detail
template<length_t L, typename T, qualifier Q, bool Aligned> template<length_t L, typename T, qualifier Q, bool Aligned>
struct compute_mix_vector<L, T, bool, Q, Aligned> struct compute_mix_vector<L, T, bool, Q, Aligned>
{ {
GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, bool, Q> const& a) GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, bool, Q> const& a)
{ {
vec<L, T, Q> Result; vec<L, T, Q> Result;
for(length_t i = 0; i < x.length(); ++i) for(length_t i = 0; i < x.length(); ++i)
@ -103,7 +103,7 @@ namespace detail
template<length_t L, typename T, typename U, qualifier Q, bool Aligned> template<length_t L, typename T, typename U, qualifier Q, bool Aligned>
struct compute_mix_scalar struct compute_mix_scalar
{ {
GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, U const& a) GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, U const& a)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a"); GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
@ -114,7 +114,7 @@ namespace detail
template<length_t L, typename T, qualifier Q, bool Aligned> template<length_t L, typename T, qualifier Q, bool Aligned>
struct compute_mix_scalar<L, T, bool, Q, Aligned> struct compute_mix_scalar<L, T, bool, Q, Aligned>
{ {
GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, bool const& a) GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, T, Q> call(vec<L, T, Q> const& x, vec<L, T, Q> const& y, bool const& a)
{ {
return a ? y : x; return a ? y : x;
} }
@ -123,7 +123,7 @@ namespace detail
template<typename T, typename U> template<typename T, typename U>
struct compute_mix struct compute_mix
{ {
GLM_FUNC_QUALIFIER static T call(T const& x, T const& y, U const& a) GLM_FUNC_QUALIFIER GLM_CONSTEXPR static T call(T const& x, T const& y, U const& a)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a"); GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_CONFIG_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
@ -134,7 +134,7 @@ namespace detail
template<typename T> template<typename T>
struct compute_mix<T, bool> struct compute_mix<T, bool>
{ {
GLM_FUNC_QUALIFIER static T call(T const& x, T const& y, bool const& a) GLM_FUNC_QUALIFIER GLM_CONSTEXPR static T call(T const& x, T const& y, bool const& a)
{ {
return a ? y : x; return a ? y : x;
} }
@ -143,7 +143,7 @@ namespace detail
template<length_t L, typename T, qualifier Q, bool isFloat, bool Aligned> template<length_t L, typename T, qualifier Q, bool isFloat, bool Aligned>
struct compute_sign struct compute_sign
{ {
GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, T, Q> call(vec<L, T, Q> const& x)
{ {
return vec<L, T, Q>(glm::lessThan(vec<L, T, Q>(0), x)) - vec<L, T, Q>(glm::lessThan(x, vec<L, T, Q>(0))); return vec<L, T, Q>(glm::lessThan(vec<L, T, Q>(0), x)) - vec<L, T, Q>(glm::lessThan(x, vec<L, T, Q>(0)));
} }
@ -153,7 +153,7 @@ namespace detail
template<length_t L, typename T, qualifier Q, bool Aligned> template<length_t L, typename T, qualifier Q, bool Aligned>
struct compute_sign<L, T, Q, false, Aligned> struct compute_sign<L, T, Q, false, Aligned>
{ {
GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER GLM_CONSTEXPR static vec<L, T, Q> call(vec<L, T, Q> const& x)
{ {
T const Shift(static_cast<T>(sizeof(T) * 8 - 1)); T const Shift(static_cast<T>(sizeof(T) * 8 - 1));
vec<L, T, Q> const y(vec<L, typename detail::make_unsigned<T>::type, Q>(-x) >> typename detail::make_unsigned<T>::type(Shift)); vec<L, T, Q> const y(vec<L, typename detail::make_unsigned<T>::type, Q>(-x) >> typename detail::make_unsigned<T>::type(Shift));
@ -281,7 +281,7 @@ namespace detail
// sign // sign
// fast and works for any type // fast and works for any type
template<typename genFIType> template<typename genFIType>
GLM_FUNC_QUALIFIER genFIType sign(genFIType x) GLM_FUNC_QUALIFIER GLM_CONSTEXPR genFIType sign(genFIType x)
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(
std::numeric_limits<genFIType>::is_iec559 || (std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer), std::numeric_limits<genFIType>::is_iec559 || (std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer),
@ -292,7 +292,7 @@ namespace detail
} }
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> sign(vec<L, T, Q> const& x) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> sign(vec<L, T, Q> const& x)
{ {
GLM_STATIC_ASSERT( GLM_STATIC_ASSERT(
std::numeric_limits<T>::is_iec559 || (std::numeric_limits<T>::is_signed && std::numeric_limits<T>::is_integer), std::numeric_limits<T>::is_iec559 || (std::numeric_limits<T>::is_signed && std::numeric_limits<T>::is_integer),
@ -523,19 +523,19 @@ namespace detail
} }
template<typename genTypeT, typename genTypeU> template<typename genTypeT, typename genTypeU>
GLM_FUNC_QUALIFIER genTypeT mix(genTypeT x, genTypeT y, genTypeU a) GLM_FUNC_QUALIFIER GLM_CONSTEXPR genTypeT mix(genTypeT x, genTypeT y, genTypeU a)
{ {
return detail::compute_mix<genTypeT, genTypeU>::call(x, y, a); return detail::compute_mix<genTypeT, genTypeU>::call(x, y, a);
} }
template<length_t L, typename T, typename U, qualifier Q> template<length_t L, typename T, typename U, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> mix(vec<L, T, Q> const& x, vec<L, T, Q> const& y, U a) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> mix(vec<L, T, Q> const& x, vec<L, T, Q> const& y, U a)
{ {
return detail::compute_mix_scalar<L, T, U, Q, detail::is_aligned<Q>::value>::call(x, y, a); return detail::compute_mix_scalar<L, T, U, Q, detail::is_aligned<Q>::value>::call(x, y, a);
} }
template<length_t L, typename T, typename U, qualifier Q> template<length_t L, typename T, typename U, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> mix(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, U, Q> const& a) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, Q> mix(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, U, Q> const& a)
{ {
return detail::compute_mix_vector<L, T, U, Q, detail::is_aligned<Q>::value>::call(x, y, a); return detail::compute_mix_vector<L, T, U, Q, detail::is_aligned<Q>::value>::call(x, y, a);
} }

2
glm/ext/matrix_transform.hpp
View File

@ -61,7 +61,7 @@ namespace glm
/// @see - translate(vec<3, T, Q> const& v) /// @see - translate(vec<3, T, Q> const& v)
/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glTranslate.xml">glTranslate man page</a> /// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glTranslate.xml">glTranslate man page</a>
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_DECL mat<4, 4, T, Q> translate( GLM_FUNC_DECL GLM_CONSTEXPR mat<4, 4, T, Q> translate(
mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v); mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v);
/// Builds a rotation 4 * 4 matrix created from an axis vector and an angle. /// Builds a rotation 4 * 4 matrix created from an axis vector and an angle.

2
glm/ext/matrix_transform.inl
View File

@ -7,7 +7,7 @@ namespace glm
} }
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER mat<4, 4, T, Q> translate(mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v) GLM_FUNC_QUALIFIER GLM_CONSTEXPR mat<4, 4, T, Q> translate(mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v)
{ {
mat<4, 4, T, Q> Result(m); mat<4, 4, T, Q> Result(m);
Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3]; Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3];

6
glm/ext/quaternion_common.hpp
View File

@ -62,7 +62,7 @@ namespace glm
/// @tparam T A floating-point scalar type /// @tparam T A floating-point scalar type
/// @tparam Q A value from qualifier enum /// @tparam Q A value from qualifier enum
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_DECL qua<T, Q> lerp(qua<T, Q> const& x, qua<T, Q> const& y, T a); GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q> lerp(qua<T, Q> const& x, qua<T, Q> const& y, T a);
/// Spherical linear interpolation of two quaternions. /// Spherical linear interpolation of two quaternions.
/// The interpolation always take the short path and the rotation is performed at constant speed. /// The interpolation always take the short path and the rotation is performed at constant speed.
@ -96,14 +96,14 @@ namespace glm
/// @tparam T A floating-point scalar type /// @tparam T A floating-point scalar type
/// @tparam Q A value from qualifier enum /// @tparam Q A value from qualifier enum
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_DECL qua<T, Q> conjugate(qua<T, Q> const& q); GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q> conjugate(qua<T, Q> const& q);
/// Returns the q inverse. /// Returns the q inverse.
/// ///
/// @tparam T A floating-point scalar type /// @tparam T A floating-point scalar type
/// @tparam Q A value from qualifier enum /// @tparam Q A value from qualifier enum
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_DECL qua<T, Q> inverse(qua<T, Q> const& q); GLM_FUNC_DECL GLM_CONSTEXPR qua<T, Q> inverse(qua<T, Q> const& q);
/// Returns true if x holds a NaN (not a number) /// Returns true if x holds a NaN (not a number)
/// representation in the underlying implementation's set of /// representation in the underlying implementation's set of

6
glm/ext/quaternion_common.inl
View File

@ -26,7 +26,7 @@ namespace glm
} }
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER qua<T, Q> lerp(qua<T, Q> const& x, qua<T, Q> const& y, T a) GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> lerp(qua<T, Q> const& x, qua<T, Q> const& y, T a)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'lerp' only accept floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'lerp' only accept floating-point inputs");
@ -110,13 +110,13 @@ namespace glm
} }
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER qua<T, Q> conjugate(qua<T, Q> const& q) GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> conjugate(qua<T, Q> const& q)
{ {
return qua<T, Q>::wxyz(q.w, -q.x, -q.y, -q.z); return qua<T, Q>::wxyz(q.w, -q.x, -q.y, -q.z);
} }
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER qua<T, Q> inverse(qua<T, Q> const& q) GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> inverse(qua<T, Q> const& q)
{ {
return conjugate(q) / dot(q, q); return conjugate(q) / dot(q, q);
} }

4
glm/ext/quaternion_geometric.hpp
View File

@ -53,7 +53,7 @@ namespace glm
/// ///
/// @see ext_quaternion_geometric /// @see ext_quaternion_geometric
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_DECL T dot(qua<T, Q> const& x, qua<T, Q> const& y); GLM_FUNC_DECL GLM_CONSTEXPR T dot(qua<T, Q> const& x, qua<T, Q> const& y);
/// Compute a cross product. /// Compute a cross product.
/// ///
@ -62,7 +62,7 @@ namespace glm
/// ///
/// @see ext_quaternion_geometric /// @see ext_quaternion_geometric
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER qua<T, Q> cross(qua<T, Q> const& q1, qua<T, Q> const& q2); GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> cross(qua<T, Q> const& q1, qua<T, Q> const& q2);
/// @} /// @}
} //namespace glm } //namespace glm

4
glm/ext/quaternion_geometric.inl
View File

@ -1,7 +1,7 @@
namespace glm namespace glm
{ {
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER T dot(qua<T, Q> const& x, qua<T, Q> const& y) GLM_FUNC_QUALIFIER GLM_CONSTEXPR T dot(qua<T, Q> const& x, qua<T, Q> const& y)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' accepts only floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' accepts only floating-point inputs");
return detail::compute_dot<qua<T, Q>, T, detail::is_aligned<Q>::value>::call(x, y); return detail::compute_dot<qua<T, Q>, T, detail::is_aligned<Q>::value>::call(x, y);
@ -24,7 +24,7 @@ namespace glm
} }
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER qua<T, Q> cross(qua<T, Q> const& q1, qua<T, Q> const& q2) GLM_FUNC_QUALIFIER GLM_CONSTEXPR qua<T, Q> cross(qua<T, Q> const& q1, qua<T, Q> const& q2)
{ {
return qua<T, Q>::wxyz( return qua<T, Q>::wxyz(
q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z, q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z,

8
glm/gtc/quaternion.hpp
View File

@ -112,7 +112,7 @@ namespace glm
/// ///
/// @see ext_quaternion_relational /// @see ext_quaternion_relational
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_DECL vec<4, bool, Q> lessThan(qua<T, Q> const& x, qua<T, Q> const& y); GLM_FUNC_DECL GLM_CONSTEXPR vec<4, bool, Q> lessThan(qua<T, Q> const& x, qua<T, Q> const& y);
/// Returns the component-wise comparison of result x <= y. /// Returns the component-wise comparison of result x <= y.
/// ///
@ -121,7 +121,7 @@ namespace glm
/// ///
/// @see ext_quaternion_relational /// @see ext_quaternion_relational
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_DECL vec<4, bool, Q> lessThanEqual(qua<T, Q> const& x, qua<T, Q> const& y); GLM_FUNC_DECL GLM_CONSTEXPR vec<4, bool, Q> lessThanEqual(qua<T, Q> const& x, qua<T, Q> const& y);
/// Returns the component-wise comparison of result x > y. /// Returns the component-wise comparison of result x > y.
/// ///
@ -130,7 +130,7 @@ namespace glm
/// ///
/// @see ext_quaternion_relational /// @see ext_quaternion_relational
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_DECL vec<4, bool, Q> greaterThan(qua<T, Q> const& x, qua<T, Q> const& y); GLM_FUNC_DECL GLM_CONSTEXPR vec<4, bool, Q> greaterThan(qua<T, Q> const& x, qua<T, Q> const& y);
/// Returns the component-wise comparison of result x >= y. /// Returns the component-wise comparison of result x >= y.
/// ///
@ -139,7 +139,7 @@ namespace glm
/// ///
/// @see ext_quaternion_relational /// @see ext_quaternion_relational
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_DECL vec<4, bool, Q> greaterThanEqual(qua<T, Q> const& x, qua<T, Q> const& y); GLM_FUNC_DECL GLM_CONSTEXPR vec<4, bool, Q> greaterThanEqual(qua<T, Q> const& x, qua<T, Q> const& y);
/// Build a look at quaternion based on the default handedness. /// Build a look at quaternion based on the default handedness.
/// ///

16
glm/gtc/quaternion.inl
View File

@ -129,36 +129,36 @@ namespace glm
} }
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<4, bool, Q> lessThan(qua<T, Q> const& x, qua<T, Q> const& y) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, bool, Q> lessThan(qua<T, Q> const& x, qua<T, Q> const& y)
{ {
vec<4, bool, Q> Result; vec<4, bool, Q> Result(false, false, false, false);
for(length_t i = 0; i < x.length(); ++i) for(length_t i = 0; i < x.length(); ++i)
Result[i] = x[i] < y[i]; Result[i] = x[i] < y[i];
return Result; return Result;
} }
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<4, bool, Q> lessThanEqual(qua<T, Q> const& x, qua<T, Q> const& y) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, bool, Q> lessThanEqual(qua<T, Q> const& x, qua<T, Q> const& y)
{ {
vec<4, bool, Q> Result; vec<4, bool, Q> Result(false, false, false, false);
for(length_t i = 0; i < x.length(); ++i) for(length_t i = 0; i < x.length(); ++i)
Result[i] = x[i] <= y[i]; Result[i] = x[i] <= y[i];
return Result; return Result;
} }
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<4, bool, Q> greaterThan(qua<T, Q> const& x, qua<T, Q> const& y) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, bool, Q> greaterThan(qua<T, Q> const& x, qua<T, Q> const& y)
{ {
vec<4, bool, Q> Result; vec<4, bool, Q> Result(false, false, false, false);
for(length_t i = 0; i < x.length(); ++i) for(length_t i = 0; i < x.length(); ++i)
Result[i] = x[i] > y[i]; Result[i] = x[i] > y[i];
return Result; return Result;
} }
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<4, bool, Q> greaterThanEqual(qua<T, Q> const& x, qua<T, Q> const& y) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<4, bool, Q> greaterThanEqual(qua<T, Q> const& x, qua<T, Q> const& y)
{ {
vec<4, bool, Q> Result; vec<4, bool, Q> Result(false, false, false, false);
for(length_t i = 0; i < x.length(); ++i) for(length_t i = 0; i < x.length(); ++i)
Result[i] = x[i] >= y[i]; Result[i] = x[i] >= y[i];
return Result; return Result;

2
glm/gtx/exterior_product.hpp
View File

@ -37,7 +37,7 @@ namespace glm
/// ///
/// @see <a href="https://en.wikipedia.org/wiki/Exterior_algebra#Cross_and_triple_products">Exterior product</a> /// @see <a href="https://en.wikipedia.org/wiki/Exterior_algebra#Cross_and_triple_products">Exterior product</a>
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_DECL T cross(vec<2, T, Q> const& v, vec<2, T, Q> const& u); GLM_FUNC_DECL GLM_CONSTEXPR T cross(vec<2, T, Q> const& v, vec<2, T, Q> const& u);
/// @} /// @}
} //namespace glm } //namespace glm

4
glm/gtx/exterior_product.inl
View File

@ -8,7 +8,7 @@ namespace detail
template<typename T, qualifier Q, bool Aligned> template<typename T, qualifier Q, bool Aligned>
struct compute_cross_vec2 struct compute_cross_vec2
{ {
GLM_FUNC_QUALIFIER static T call(vec<2, T, Q> const& v, vec<2, T, Q> const& u) GLM_FUNC_QUALIFIER GLM_CONSTEXPR static T call(vec<2, T, Q> const& v, vec<2, T, Q> const& u)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cross' accepts only floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cross' accepts only floating-point inputs");
@ -18,7 +18,7 @@ namespace detail
}//namespace detail }//namespace detail
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER T cross(vec<2, T, Q> const& x, vec<2, T, Q> const& y) GLM_FUNC_QUALIFIER GLM_CONSTEXPR T cross(vec<2, T, Q> const& x, vec<2, T, Q> const& y)
{ {
return detail::compute_cross_vec2<T, Q, detail::is_aligned<Q>::value>::call(x, y); return detail::compute_cross_vec2<T, Q, detail::is_aligned<Q>::value>::call(x, y);
} }

4
glm/gtx/quaternion.hpp
View File

@ -43,7 +43,7 @@ namespace glm
/// ///
/// @see gtx_quaternion /// @see gtx_quaternion
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_DECL vec<3, T, Q> cross( GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> cross(
qua<T, Q> const& q, qua<T, Q> const& q,
vec<3, T, Q> const& v); vec<3, T, Q> const& v);
@ -51,7 +51,7 @@ namespace glm
/// ///
/// @see gtx_quaternion /// @see gtx_quaternion
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_DECL vec<3, T, Q> cross( GLM_FUNC_DECL GLM_CONSTEXPR vec<3, T, Q> cross(
vec<3, T, Q> const& v, vec<3, T, Q> const& v,
qua<T, Q> const& q); qua<T, Q> const& q);

4
glm/gtx/quaternion.inl
View File

@ -12,13 +12,13 @@ namespace glm
} }
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<3, T, Q> cross(vec<3, T, Q> const& v, qua<T, Q> const& q) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> cross(vec<3, T, Q> const& v, qua<T, Q> const& q)
{ {
return inverse(q) * v; return inverse(q) * v;
} }
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<3, T, Q> cross(qua<T, Q> const& q, vec<3, T, Q> const& v) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<3, T, Q> cross(qua<T, Q> const& q, vec<3, T, Q> const& v)
{ {
return q * v; return q * v;
} }