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

Renamed precision enum to qualifier

Browse Source
This commit is contained in:
Christophe Riccio 2017-08-15 21:23:47 +02:00
parent a7b72ec5b2
commit a805fb9d68
201 changed files with 5026 additions and 5127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
glm/detail/_noise.hpp
View File

@ -23,19 +23,19 @@ namespace detail
return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> permute(vec<2, T, P> const & x)
{
return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> permute(vec<3, T, P> const & x)
{
return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> permute(vec<4, T, P> const & x)
{
return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
@ -47,37 +47,37 @@ namespace detail
return T(1.79284291400159) - T(0.85373472095314) * r;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> taylorInvSqrt(vec<2, T, P> const & r)
{
return T(1.79284291400159) - T(0.85373472095314) * r;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> taylorInvSqrt(vec<3, T, P> const & r)
{
return T(1.79284291400159) - T(0.85373472095314) * r;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> taylorInvSqrt(vec<4, T, P> const & r)
{
return T(1.79284291400159) - T(0.85373472095314) * r;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> fade(vec<2, T, P> const & t)
{
return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> fade(vec<3, T, P> const & t)
{
return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> fade(vec<4, T, P> const & t)
{
return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));

18
glm/detail/_swizzle.hpp
View File

@ -20,24 +20,24 @@ namespace detail
char _buffer[1];
};
template<int N, typename T, precision P, int E0, int E1, int E2, int E3, bool Aligned>
template<int N, typename T, qualifier P, int E0, int E1, int E2, int E3, bool Aligned>
struct _swizzle_base1 : public _swizzle_base0<T, N>
{
};
template<typename T, precision P, int E0, int E1, bool Aligned>
template<typename T, qualifier P, int E0, int E1, bool Aligned>
struct _swizzle_base1<2, T, P, E0,E1,-1,-2, Aligned> : public _swizzle_base0<T, 2>
{
GLM_FUNC_QUALIFIER vec<2, T, P> operator ()() const { return vec<2, T, P>(this->elem(E0), this->elem(E1)); }
};
template<typename T, precision P, int E0, int E1, int E2, bool Aligned>
template<typename T, qualifier P, int E0, int E1, int E2, bool Aligned>
struct _swizzle_base1<3, T, P, E0,E1,E2,-1, Aligned> : public _swizzle_base0<T, 3>
{
GLM_FUNC_QUALIFIER vec<3, T, P> operator ()() const { return vec<3, T, P>(this->elem(E0), this->elem(E1), this->elem(E2)); }
};
template<typename T, precision P, int E0, int E1, int E2, int E3, bool Aligned>
template<typename T, qualifier P, int E0, int E1, int E2, int E3, bool Aligned>
struct _swizzle_base1<4, T, P, E0,E1,E2,E3, Aligned> : public _swizzle_base0<T, 4>
{
GLM_FUNC_QUALIFIER vec<4, T, P> operator ()() const { return vec<4, T, P>(this->elem(E0), this->elem(E1), this->elem(E2), this->elem(E3)); }
@ -54,7 +54,7 @@ namespace detail
DUPLICATE_ELEMENTS = 1 if there is a repeated element, 0 otherwise (used to specialize swizzles
containing duplicate elements so that they cannot be used as r-values).
*/
template<int N, typename T, precision P, int E0, int E1, int E2, int E3, int DUPLICATE_ELEMENTS>
template<int N, typename T, qualifier P, int E0, int E1, int E2, int E3, int DUPLICATE_ELEMENTS>
struct _swizzle_base2 : public _swizzle_base1<N, T, P, E0,E1,E2,E3, detail::is_aligned<P>::value>
{
GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const T& t)
@ -132,7 +132,7 @@ namespace detail
};
// Specialization for swizzles containing duplicate elements. These cannot be modified.
template<int N, typename T, precision P, int E0, int E1, int E2, int E3>
template<int N, typename T, qualifier P, int E0, int E1, int E2, int E3>
struct _swizzle_base2<N, T, P, E0,E1,E2,E3, 1> : public _swizzle_base1<N, T, P, E0,E1,E2,E3, detail::is_aligned<P>::value>
{
struct Stub {};
@ -146,7 +146,7 @@ namespace detail
}
};
template<int N, typename T, precision P, int E0, int E1, int E2, int E3>
template<int N, typename T, qualifier P, int E0, int E1, int E2, int E3>
struct _swizzle : public _swizzle_base2<N, T, P, E0, E1, E2, E3, (E0 == E1 || E0 == E2 || E0 == E3 || E1 == E2 || E1 == E3 || E2 == E3)>
{
typedef _swizzle_base2<N, T, P, E0, E1, E2, E3, (E0 == E1 || E0 == E2 || E0 == E3 || E1 == E2 || E1 == E3 || E2 == E3)> base_type;
@ -159,8 +159,8 @@ namespace detail
//
// To prevent the C++ syntax from getting entirely overwhelming, define some alias macros
//
#define GLM_SWIZZLE_TEMPLATE1 template<int N, typename T, precision P, int E0, int E1, int E2, int E3>
#define GLM_SWIZZLE_TEMPLATE2 template<int N, typename T, precision P, int E0, int E1, int E2, int E3, int F0, int F1, int F2, int F3>
#define GLM_SWIZZLE_TEMPLATE1 template<int N, typename T, qualifier P, int E0, int E1, int E2, int E3>
#define GLM_SWIZZLE_TEMPLATE2 template<int N, typename T, qualifier P, int E0, int E1, int E2, int E3, int F0, int F1, int F2, int F3>
#define GLM_SWIZZLE_TYPE1 _swizzle<N, T, P, E0, E1, E2, E3>
#define GLM_SWIZZLE_TYPE2 _swizzle<N, T, P, F0, F1, F2, F3>

30
glm/detail/_vectorize.hpp
View File

@ -11,10 +11,10 @@
namespace glm{
namespace detail
{
template<length_t L, typename R, typename T, precision P>
template<length_t L, typename R, typename T, qualifier P>
struct functor1{};
template<typename R, typename T, precision P>
template<typename R, typename T, qualifier P>
struct functor1<1, R, T, P>
{
GLM_FUNC_QUALIFIER static vec<1, R, P> call(R (*Func) (T x), vec<1, T, P> const & v)
@ -23,7 +23,7 @@ namespace detail
}
};
template<typename R, typename T, precision P>
template<typename R, typename T, qualifier P>
struct functor1<2, R, T, P>
{
GLM_FUNC_QUALIFIER static vec<2, R, P> call(R (*Func) (T x), vec<2, T, P> const & v)
@ -32,7 +32,7 @@ namespace detail
}
};
template<typename R, typename T, precision P>
template<typename R, typename T, qualifier P>
struct functor1<3, R, T, P>
{
GLM_FUNC_QUALIFIER static vec<3, R, P> call(R (*Func) (T x), vec<3, T, P> const & v)
@ -41,7 +41,7 @@ namespace detail
}
};
template<typename R, typename T, precision P>
template<typename R, typename T, qualifier P>
struct functor1<4, R, T, P>
{
GLM_FUNC_QUALIFIER static vec<4, R, P> call(R (*Func) (T x), vec<4, T, P> const & v)
@ -50,10 +50,10 @@ namespace detail
}
};
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
struct functor2{};
template<typename T, precision P>
template<typename T, qualifier P>
struct functor2<1, T, P>
{
GLM_FUNC_QUALIFIER static vec<1, T, P> call(T (*Func) (T x, T y), vec<1, T, P> const & a, vec<1, T, P> const & b)
@ -62,7 +62,7 @@ namespace detail
}
};
template<typename T, precision P>
template<typename T, qualifier P>
struct functor2<2, T, P>
{
GLM_FUNC_QUALIFIER static vec<2, T, P> call(T (*Func) (T x, T y), vec<2, T, P> const & a, vec<2, T, P> const & b)
@ -71,7 +71,7 @@ namespace detail
}
};
template<typename T, precision P>
template<typename T, qualifier P>
struct functor2<3, T, P>
{
GLM_FUNC_QUALIFIER static vec<3, T, P> call(T (*Func) (T x, T y), vec<3, T, P> const & a, vec<3, T, P> const & b)
@ -80,7 +80,7 @@ namespace detail
}
};
template<typename T, precision P>
template<typename T, qualifier P>
struct functor2<4, T, P>
{
GLM_FUNC_QUALIFIER static vec<4, T, P> call(T (*Func) (T x, T y), vec<4, T, P> const & a, vec<4, T, P> const & b)
@ -89,10 +89,10 @@ namespace detail
}
};
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
struct functor2_vec_sca{};
template<typename T, precision P>
template<typename T, qualifier P>
struct functor2_vec_sca<1, T, P>
{
GLM_FUNC_QUALIFIER static vec<1, T, P> call(T (*Func) (T x, T y), vec<1, T, P> const & a, T b)
@ -101,7 +101,7 @@ namespace detail
}
};
template<typename T, precision P>
template<typename T, qualifier P>
struct functor2_vec_sca<2, T, P>
{
GLM_FUNC_QUALIFIER static vec<2, T, P> call(T (*Func) (T x, T y), vec<2, T, P> const & a, T b)
@ -110,7 +110,7 @@ namespace detail
}
};
template<typename T, precision P>
template<typename T, qualifier P>
struct functor2_vec_sca<3, T, P>
{
GLM_FUNC_QUALIFIER static vec<3, T, P> call(T (*Func) (T x, T y), vec<3, T, P> const & a, T b)
@ -119,7 +119,7 @@ namespace detail
}
};
template<typename T, precision P>
template<typename T, qualifier P>
struct functor2_vec_sca<4, T, P>
{
GLM_FUNC_QUALIFIER static vec<4, T, P> call(T (*Func) (T x, T y), vec<4, T, P> const & a, T b)

108
glm/detail/func_common.hpp
View File

@ -11,7 +11,7 @@
#pragma once
#include "setup.hpp"
#include "precision.hpp"
#include "qualifier.hpp"
#include "type_int.hpp"
#include "_fixes.hpp"
@ -26,7 +26,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/abs.xml">GLSL abs 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 precision
/// @see qualifier
template<typename genType>
GLM_FUNC_DECL genType abs(genType x);
@ -34,33 +34,33 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point or signed integer scalar types
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/abs.xml">GLSL abs 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>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> abs(vec<L, T, P> const& x);
/// Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <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>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> sign(vec<L, T, P> const& x);
/// Returns a value equal to the nearest integer that is less then or equal to x.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floor.xml">GLSL floor 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>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> floor(vec<L, T, P> const& x);
/// Returns a value equal to the nearest integer to x
@ -68,11 +68,11 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/trunc.xml">GLSL trunc 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>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> trunc(vec<L, T, P> const& x);
/// Returns a value equal to the nearest integer to x.
@ -83,11 +83,11 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/round.xml">GLSL round 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>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> round(vec<L, T, P> const& x);
/// Returns a value equal to the nearest integer to x.
@ -96,12 +96,12 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/roundEven.xml">GLSL roundEven 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://developer.amd.com/documentation/articles/pages/New-Round-to-Even-Technique.aspx">New round to even technique</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> roundEven(vec<L, T, P> const& x);
/// Returns a value equal to the nearest integer
@ -109,11 +109,11 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ceil.xml">GLSL ceil 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>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> ceil(vec<L, T, P> const& x);
/// Return x - floor(x).
@ -129,11 +129,11 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fract.xml">GLSL fract 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>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> fract(vec<L, T, P> const& x);
/// Modulus. Returns x - y * floor(x / y)
@ -151,11 +151,11 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod 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>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> mod(vec<L, T, P> const& x, T y);
/// Modulus. Returns x - y * floor(x / y)
@ -163,11 +163,11 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod 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>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> mod(vec<L, T, P> const& x, vec<L, T, P> const& y);
/// Returns the fractional part of x and sets i to the integer
@ -195,22 +195,22 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point or integer scalar types
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/min.xml">GLSL min 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>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> min(vec<L, T, P> const& x, T y);
/// Returns y if y < x; otherwise, it returns x.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point or integer scalar types
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/min.xml">GLSL min 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>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> min(vec<L, T, P> const& x, vec<L, T, P> const& y);
/// Returns y if x < y; otherwise, it returns x.
@ -226,22 +226,22 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point or integer scalar types
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/max.xml">GLSL max 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>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> max(vec<L, T, P> const& x, T y);
/// Returns y if x < y; otherwise, it returns x.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point or integer scalar types
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/max.xml">GLSL max 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>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> max(vec<L, T, P> const& x, vec<L, T, P> const& y);
/// Returns min(max(x, minVal), maxVal) for each component in x
@ -259,11 +259,11 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point or integer scalar types
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/clamp.xml">GLSL clamp 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>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> clamp(vec<L, T, P> const & x, T minVal, T maxVal);
/// Returns min(max(x, minVal), maxVal) for each component in x
@ -271,11 +271,11 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point or integer scalar types
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/clamp.xml">GLSL clamp 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>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> clamp(vec<L, T, P> const& x, vec<L, T, P> const& minVal, vec<L, T, P> const& maxVal);
/// If genTypeU is a floating scalar or vector:
@ -323,10 +323,10 @@ namespace glm
template<typename genTypeT, typename genTypeU>
GLM_FUNC_DECL genTypeT mix(genTypeT x, genTypeT y, genTypeU a);
template<length_t L, typename T, typename U, precision P>
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_DECL vec<L, T, P> mix(vec<L, T, P> const& x, vec<L, T, P> const& y, vec<L, U, P> const& a);
template<length_t L, typename T, typename U, precision P>
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_DECL vec<L, T, P> mix(vec<L, T, P> const& x, vec<L, T, P> const& y, U a);
/// Returns 0.0 if x < edge, otherwise it returns 1.0 for each component of a genType.
@ -340,22 +340,22 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step 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>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> step(T edge, vec<L, T, P> const& x);
/// Returns 0.0 if x < edge, otherwise it returns 1.0.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step 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>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> step(vec<L, T, P> const& edge, vec<L, T, P> const& x);
/// Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and
@ -375,10 +375,10 @@ namespace glm
template<typename genType>
GLM_FUNC_DECL genType smoothstep(genType edge0, genType edge1, genType x);
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> smoothstep(T edge0, T edge1, vec<L, T, P> const& x);
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> smoothstep(vec<L, T, P> const& edge0, vec<L, T, P> const& edge1, vec<L, T, P> const& x);
/// Returns true if x holds a NaN (not a number)
@ -391,11 +391,11 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isnan.xml">GLSL isnan 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>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, bool, P> isnan(vec<L, T, P> const& x);
/// Returns true if x holds a positive infinity or negative
@ -406,11 +406,11 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isinf.xml">GLSL isinf 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>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, bool, P> isinf(vec<L, T, P> const& x);
/// Returns a signed integer value representing
@ -426,11 +426,11 @@ namespace glm
/// value's bit-level representation is preserved.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToInt.xml">GLSL floatBitsToInt 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>
template<length_t L, precision P>
template<length_t L, qualifier P>
GLM_FUNC_DECL vec<L, int, P> floatBitsToInt(vec<L, float, P> const& v);
/// Returns a unsigned integer value representing
@ -446,11 +446,11 @@ namespace glm
/// value's bit-level representation is preserved.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToUint.xml">GLSL floatBitsToUint 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>
template<length_t L, precision P>
template<length_t L, qualifier P>
GLM_FUNC_DECL vec<L, uint, P> floatBitsToUint(vec<L, float, P> const& v);
/// Returns a floating-point value corresponding to a signed
@ -470,11 +470,11 @@ namespace glm
/// the bit-level representation is preserved.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/intBitsToFloat.xml">GLSL intBitsToFloat 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>
template<length_t L, precision P>
template<length_t L, qualifier P>
GLM_FUNC_DECL vec<L, float, P> intBitsToFloat(vec<L, int, P> const& v);
/// Returns a floating-point value corresponding to a
@ -494,11 +494,11 @@ namespace glm
/// the bit-level representation is preserved.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam P Value from precision enum
/// @tparam P Value from qualifier enum
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uintBitsToFloat.xml">GLSL uintBitsToFloat 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>
template<length_t L, precision P>
template<length_t L, qualifier P>
GLM_FUNC_DECL vec<L, float, P> uintBitsToFloat(vec<L, uint, P> const& v);
/// Computes and returns a * b + c.

116
glm/detail/func_common.inl
View File

@ -107,7 +107,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_abs_vector
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const & x)
@ -116,7 +116,7 @@ namespace detail
}
};
template<length_t L, typename T, typename U, precision P, bool Aligned>
template<length_t L, typename T, typename U, qualifier P, bool Aligned>
struct compute_mix_vector
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& x, vec<L, T, P> const& y, vec<L, U, P> const& a)
@ -127,7 +127,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_mix_vector<L, T, bool, P, Aligned>
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& x, vec<L, T, P> const& y, vec<L, bool, P> const& a)
@ -139,7 +139,7 @@ namespace detail
}
};
template<length_t L, typename T, typename U, precision P, bool Aligned>
template<length_t L, typename T, typename U, qualifier P, bool Aligned>
struct compute_mix_scalar
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& x, vec<L, T, P> const& y, U const& a)
@ -150,7 +150,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_mix_scalar<L, T, bool, P, Aligned>
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& x, vec<L, T, P> const& y, bool const& a)
@ -179,7 +179,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, bool isFloat, bool Aligned>
template<length_t L, typename T, qualifier P, bool isFloat, bool Aligned>
struct compute_sign
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& x)
@ -189,7 +189,7 @@ namespace detail
};
# if GLM_ARCH == GLM_ARCH_X86
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_sign<L, T, P, false, Aligned>
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& x)
@ -202,7 +202,7 @@ namespace detail
};
# endif
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_floor
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& x)
@ -211,7 +211,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_ceil
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& x)
@ -220,7 +220,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_fract
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& x)
@ -229,7 +229,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_trunc
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& x)
@ -238,7 +238,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_round
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& x)
@ -247,7 +247,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_mod
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& a, vec<L, T, P> const& b)
@ -257,7 +257,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_min_vector
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& x, vec<L, T, P> const& y)
@ -266,7 +266,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_max_vector
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& x, vec<L, T, P> const& y)
@ -275,7 +275,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_clamp_vector
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& x, vec<L, T, P> const& minVal, vec<L, T, P> const& maxVal)
@ -284,7 +284,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_step_vector
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& edge, vec<L, T, P> const& x)
@ -293,7 +293,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_smoothstep_vector
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& edge0, vec<L, T, P> const& edge1, vec<L, T, P> const& x)
@ -311,7 +311,7 @@ namespace detail
return detail::compute_abs<genFIType, std::numeric_limits<genFIType>::is_signed>::call(x);
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> abs(vec<L, T, P> const & x)
{
return detail::compute_abs_vector<L, T, P, detail::is_aligned<P>::value>::call(x);
@ -329,7 +329,7 @@ namespace detail
return detail::compute_sign<1, genFIType, defaultp, std::numeric_limits<genFIType>::is_iec559, highp>::call(vec<1, genFIType>(x)).x;
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> sign(vec<L, T, P> const& x)
{
GLM_STATIC_ASSERT(
@ -341,21 +341,21 @@ namespace detail
// floor
using ::std::floor;
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> floor(vec<L, T, P> const& x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'floor' only accept floating-point inputs.");
return detail::compute_floor<L, T, P, detail::is_aligned<P>::value>::call(x);
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> trunc(vec<L, T, P> const& x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'trunc' only accept floating-point inputs");
return detail::compute_trunc<L, T, P, detail::is_aligned<P>::value>::call(x);
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> round(vec<L, T, P> const& x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'round' only accept floating-point inputs");
@ -405,7 +405,7 @@ namespace detail
//}
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> roundEven(vec<L, T, P> const & x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'roundEven' only accept floating-point inputs");
@ -414,7 +414,7 @@ namespace detail
// ceil
using ::std::ceil;
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> ceil(vec<L, T, P> const & x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ceil' only accept floating-point inputs");
@ -428,7 +428,7 @@ namespace detail
return fract(vec<1, genType>(x)).x;
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> fract(vec<L, T, P> const & x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fract' only accept floating-point inputs");
@ -448,13 +448,13 @@ namespace detail
# endif
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> mod(vec<L, T, P> const & x, T y)
{
return detail::compute_mod<L, T, P, detail::is_aligned<P>::value>::call(x, vec<L, T, P>(y));
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> mod(vec<L, T, P> const& x, vec<L, T, P> const& y)
{
return detail::compute_mod<L, T, P, detail::is_aligned<P>::value>::call(x, y);
@ -468,14 +468,14 @@ namespace detail
return std::modf(x, &i);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> modf(vec<1, T, P> const & x, vec<1, T, P> & i)
{
return vec<1, T, P>(
modf(x.x, i.x));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> modf(vec<2, T, P> const & x, vec<2, T, P> & i)
{
return vec<2, T, P>(
@ -483,7 +483,7 @@ namespace detail
modf(x.y, i.y));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> modf(vec<3, T, P> const & x, vec<3, T, P> & i)
{
return vec<3, T, P>(
@ -492,7 +492,7 @@ namespace detail
modf(x.z, i.z));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> modf(vec<4, T, P> const & x, vec<4, T, P> & i)
{
return vec<4, T, P>(
@ -511,28 +511,28 @@ namespace detail
//CHAR_BIT - 1)));
// min
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> min(vec<L, T, P> const & a, T b)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer || GLM_UNRESTRICTED_GENTYPE, "'min' only accept floating-point or integer inputs");
return detail::compute_min_vector<L, T, P, detail::is_aligned<P>::value>::call(a, vec<L, T, P>(b));
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> min(vec<L, T, P> const& a, vec<L, T, P> const& b)
{
return detail::compute_min_vector<L, T, P, detail::is_aligned<P>::value>::call(a, b);
}
// max
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> max(vec<L, T, P> const& a, T b)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer || GLM_UNRESTRICTED_GENTYPE, "'max' only accept floating-point or integer inputs");
return detail::compute_max_vector<L, T, P, detail::is_aligned<P>::value>::call(a, vec<L, T, P>(b));
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> max(vec<L, T, P> const& a, vec<L, T, P> const & b)
{
return detail::compute_max_vector<L, T, P, detail::is_aligned<P>::value>::call(a, b);
@ -546,14 +546,14 @@ namespace detail
return min(max(x, minVal), maxVal);
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> clamp(vec<L, T, P> const & x, T minVal, T maxVal)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer || GLM_UNRESTRICTED_GENTYPE, "'clamp' only accept floating-point or integer inputs");
return detail::compute_clamp_vector<L, T, P, detail::is_aligned<P>::value>::call(x, vec<L, T, P>(minVal), vec<L, T, P>(maxVal));
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> clamp(vec<L, T, P> const& x, vec<L, T, P> const& minVal, vec<L, T, P> const& maxVal)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer || GLM_UNRESTRICTED_GENTYPE, "'clamp' only accept floating-point or integer inputs");
@ -566,13 +566,13 @@ namespace detail
return detail::compute_mix<genTypeT, genTypeU>::call(x, y, a);
}
template<length_t L, typename T, typename U, precision P>
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> mix(vec<L, T, P> const& x, vec<L, T, P> const& y, U a)
{
return detail::compute_mix_scalar<L, T, U, P, detail::is_aligned<P>::value>::call(x, y, a);
}
template<length_t L, typename T, typename U, precision P>
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> mix(vec<L, T, P> const& x, vec<L, T, P> const& y, vec<L, U, P> const& a)
{
return detail::compute_mix_vector<L, T, U, P, detail::is_aligned<P>::value>::call(x, y, a);
@ -585,13 +585,13 @@ namespace detail
return mix(static_cast<genType>(1), static_cast<genType>(0), glm::lessThan(x, edge));
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> step(T edge, vec<L, T, P> const& x)
{
return detail::compute_step_vector<L, T, P, detail::is_aligned<P>::value>::call(vec<L, T, P>(edge), x);
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> step(vec<L, T, P> const& edge, vec<L, T, P> const& x)
{
return detail::compute_step_vector<L, T, P, detail::is_aligned<P>::value>::call(edge, x);
@ -607,13 +607,13 @@ namespace detail
return tmp * tmp * (genType(3) - genType(2) * tmp);
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> smoothstep(T edge0, T edge1, vec<L, T, P> const& x)
{
return detail::compute_smoothstep_vector<L, T, P, detail::is_aligned<P>::value>::call(vec<L, T, P>(edge0), vec<L, T, P>(edge1), x);
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> smoothstep(vec<L, T, P> const& edge0, vec<L, T, P> const& edge1, vec<L, T, P> const& x)
{
return detail::compute_smoothstep_vector<L, T, P, detail::is_aligned<P>::value>::call(edge0, edge1, x);
@ -647,7 +647,7 @@ namespace detail
}
# endif
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, bool, P> isnan(vec<L, T, P> const& x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
@ -686,7 +686,7 @@ namespace detail
}
# endif
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, bool, P> isinf(vec<L, T, P> const& x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
@ -707,7 +707,7 @@ namespace detail
return u.out;
}
template<length_t L, precision P>
template<length_t L, qualifier P>
GLM_FUNC_QUALIFIER vec<L, int, P> floatBitsToInt(vec<L, float, P> const& v)
{
return reinterpret_cast<vec<L, int, P>&>(const_cast<vec<L, float, P>&>(v));
@ -726,7 +726,7 @@ namespace detail
return u.out;
}
template<length_t L, precision P>
template<length_t L, qualifier P>
GLM_FUNC_QUALIFIER vec<L, uint, P> floatBitsToUint(vec<L, float, P> const& v)
{
return reinterpret_cast<vec<L, uint, P>&>(const_cast<vec<L, float, P>&>(v));
@ -745,7 +745,7 @@ namespace detail
return u.out;
}
template<length_t L, precision P>
template<length_t L, qualifier P>
GLM_FUNC_QUALIFIER vec<L, float, P> intBitsToFloat(vec<L, int, P> const& v)
{
return reinterpret_cast<vec<L, float, P>&>(const_cast<vec<L, int, P>&>(v));
@ -764,7 +764,7 @@ namespace detail
return u.out;
}
template<length_t L, precision P>
template<length_t L, qualifier P>
GLM_FUNC_QUALIFIER vec<L, float, P> uintBitsToFloat(vec<L, uint, P> const& v)
{
return reinterpret_cast<vec<L, float, P>&>(const_cast<vec<L, uint, P>&>(v));
@ -784,7 +784,7 @@ namespace detail
return std::frexp(x, &exp);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> frexp(vec<1, T, P> const& x, vec<1, int, P>& exp)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs");
@ -792,7 +792,7 @@ namespace detail
return vec<1, T, P>(std::frexp(x.x, &exp.x));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> frexp(vec<2, T, P> const& x, vec<2, int, P>& exp)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs");
@ -802,7 +802,7 @@ namespace detail
frexp(x.y, exp.y));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> frexp(vec<3, T, P> const& x, vec<3, int, P>& exp)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs");
@ -813,7 +813,7 @@ namespace detail
frexp(x.z, exp.z));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> frexp(vec<4, T, P> const& x, vec<4, int, P>& exp)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs");
@ -833,7 +833,7 @@ namespace detail
return std::ldexp(x, exp);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> ldexp(vec<1, T, P> const& x, vec<1, int, P> const& exp)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs");
@ -842,7 +842,7 @@ namespace detail
ldexp(x.x, exp.x));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> ldexp(vec<2, T, P> const& x, vec<2, int, P> const& exp)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs");
@ -852,7 +852,7 @@ namespace detail
ldexp(x.y, exp.y));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> ldexp(vec<3, T, P> const& x, vec<3, int, P> const& exp)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs");
@ -863,7 +863,7 @@ namespace detail
ldexp(x.z, exp.z));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> ldexp(vec<4, T, P> const& x, vec<4, int, P> const& exp)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs");

38
glm/detail/func_common_simd.inl
View File

@ -10,7 +10,7 @@
namespace glm{
namespace detail
{
template<precision P>
template<qualifier P>
struct compute_abs_vector<4, float, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v)
@ -21,7 +21,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_abs_vector<4, int, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, int, P> call(vec<4, int, P> const & v)
@ -32,7 +32,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_floor<4, float, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v)
@ -43,7 +43,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_ceil<4, float, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v)
@ -54,7 +54,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_fract<4, float, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v)
@ -65,7 +65,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_round<4, float, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v)
@ -76,7 +76,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_mod<4, float, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & x, vec<4, float, P> const & y)
@ -87,7 +87,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_min_vector<4, float, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v1, vec<4, float, P> const & v2)
@ -98,7 +98,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_min_vector<4, int32, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, int32, P> call(vec<4, int32, P> const & v1, vec<4, int32, P> const & v2)
@ -109,7 +109,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_min_vector<4, uint32, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, int32, P> call(vec<4, uint32, P> const & v1, vec<4, uint32, P> const & v2)
@ -120,7 +120,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_max_vector<4, float, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v1, vec<4, float, P> const & v2)
@ -131,7 +131,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_max_vector<4, int32, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, int32, P> call(vec<4, int32, P> const & v1, vec<4, int32, P> const & v2)
@ -142,7 +142,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_max_vector<4, uint32, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, uint32, P> call(vec<4, uint32, P> const & v1, vec<4, uint32, P> const & v2)
@ -153,7 +153,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_clamp_vector<4, float, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & x, vec<4, float, P> const & minVal, vec<4, float, P> const & maxVal)
@ -164,7 +164,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_clamp_vector<4, int32, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, int32, P> call(vec<4, int32, P> const & x, vec<4, int32, P> const & minVal, vec<4, int32, P> const & maxVal)
@ -175,7 +175,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_clamp_vector<4, uint32, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, uint32, P> call(vec<4, uint32, P> const & x, vec<4, uint32, P> const & minVal, vec<4, uint32, P> const & maxVal)
@ -186,7 +186,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_mix_vector<4, float, bool, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & x, vec<4, float, P> const & y, vec<4, bool, P> const & a)
@ -204,7 +204,7 @@ namespace detail
}
};
/* FIXME
template<precision P>
template<qualifier P>
struct compute_step_vector<float, P, tvec4>
{
GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const& edge, vec<4, float, P> const& x)
@ -215,7 +215,7 @@ namespace detail
}
};
*/
template<precision P>
template<qualifier P>
struct compute_smoothstep_vector<4, float, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const& edge0, vec<4, float, P> const& edge1, vec<4, float, P> const& x)

28
glm/detail/func_exponential.hpp
View File

@ -23,81 +23,81 @@ namespace glm
/// Returns 'base' raised to the power 'exponent'.
///
/// @param base Floating point value. pow function is defined for input values of 'base' defined in the range (inf-, inf+) in the limit of the type precision.
/// @param base Floating point value. pow function is defined for input values of 'base' defined in the range (inf-, inf+) in the limit of the type qualifier.
/// @param exponent Floating point value representing the 'exponent'.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/pow.xml">GLSL pow man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> pow(vec<L, T, P> const & base, vec<L, T, P> const& exponent);
/// Returns the natural exponentiation of x, i.e., e^x.
///
/// @param v exp function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type precision.
/// @param v exp function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type qualifier.
/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
/// @tparam T Floating-point scalar types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp.xml">GLSL exp man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> exp(vec<L, T, P> const& v);
/// Returns the natural logarithm of v, i.e.,
/// returns the value y which satisfies the equation x = e^y.
/// Results are undefined if v <= 0.
///
/// @param v log function is defined for input values of v defined in the range (0, inf+) in the limit of the type precision.
/// @param v log function is defined for input values of v defined in the range (0, inf+) in the limit of the type qualifier.
/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
/// @tparam T Floating-point scalar types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log.xml">GLSL log man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> log(vec<L, T, P> const& v);
/// Returns 2 raised to the v power.
///
/// @param v exp2 function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type precision.
/// @param v exp2 function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type qualifier.
/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
/// @tparam T Floating-point scalar types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp2.xml">GLSL exp2 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> exp2(vec<L, T, P> const& v);
/// Returns the base 2 log of x, i.e., returns the value y,
/// which satisfies the equation x = 2 ^ y.
///
/// @param v log2 function is defined for input values of v defined in the range (0, inf+) in the limit of the type precision.
/// @param v log2 function is defined for input values of v defined in the range (0, inf+) in the limit of the type qualifier.
/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
/// @tparam T Floating-point scalar types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log2.xml">GLSL log2 man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> log2(vec<L, T, P> const& v);
/// Returns the positive square root of v.
///
/// @param v sqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type precision.
/// @param v sqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type qualifier.
/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
/// @tparam T Floating-point scalar types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sqrt.xml">GLSL sqrt man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> sqrt(vec<L, T, P> const & v);
/// Returns the reciprocal of the positive square root of v.
///
/// @param v inversesqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type precision.
/// @param v inversesqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type qualifier.
/// @tparam L An integer between 1 and 4 included that qualify the dimension of the vector.
/// @tparam T Floating-point scalar types.
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inversesqrt.xml">GLSL inversesqrt man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> inversesqrt(vec<L, T, P> const & v);
/// @}

20
glm/detail/func_exponential.inl
View File

@ -20,7 +20,7 @@ namespace detail
}
# endif
template<length_t L, typename T, precision P, bool isFloat, bool Aligned>
template<length_t L, typename T, qualifier P, bool isFloat, bool Aligned>
struct compute_log2
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& v)
@ -29,7 +29,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_sqrt
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& x)
@ -38,7 +38,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_inversesqrt
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const & x)
@ -66,7 +66,7 @@ namespace detail
// pow
using std::pow;
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> pow(vec<L, T, P> const & base, vec<L, T, P> const& exponent)
{
return detail::functor2<L, T, P>::call(pow, base, exponent);
@ -74,7 +74,7 @@ namespace detail
// exp
using std::exp;
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> exp(vec<L, T, P> const& x)
{
return detail::functor1<L, T, T, P>::call(exp, x);
@ -82,7 +82,7 @@ namespace detail
// log
using std::log;
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> log(vec<L, T, P> const& x)
{
return detail::functor1<L, T, T, P>::call(log, x);
@ -97,7 +97,7 @@ namespace detail
return std::exp(static_cast<genType>(0.69314718055994530941723212145818) * x);
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> exp2(vec<L, T, P> const& x)
{
return detail::functor1<L, T, T, P>::call(exp2, x);
@ -110,7 +110,7 @@ namespace detail
return log2(vec<1, genType>(x)).x;
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> log2(vec<L, T, P> const& x)
{
return detail::compute_log2<L, T, P, std::numeric_limits<T>::is_iec559, detail::is_aligned<P>::value>::call(x);
@ -118,7 +118,7 @@ namespace detail
// sqrt
using std::sqrt;
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> sqrt(vec<L, T, P> const& x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sqrt' only accept floating-point inputs");
@ -132,7 +132,7 @@ namespace detail
return static_cast<genType>(1) / sqrt(x);
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> inversesqrt(vec<L, T, P> const& x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'inversesqrt' only accept floating-point inputs");

2
glm/detail/func_exponential_simd.inl
View File

@ -8,7 +8,7 @@
namespace glm{
namespace detail
{
template<precision P>
template<qualifier P>
struct compute_sqrt<4, float, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v)

16
glm/detail/func_geometric.hpp
View File

@ -24,7 +24,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/length.xml">GLSL length man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL T length(vec<L, T, P> const& x);
/// Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
@ -34,7 +34,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/distance.xml">GLSL distance man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL T distance(vec<L, T, P> const& p0, vec<L, T, P> const& p1);
/// Returns the dot product of x and y, i.e., result = x * y.
@ -44,7 +44,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/dot.xml">GLSL dot man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL T dot(vec<L, T, P> const & x, vec<L, T, P> const & y);
/// Returns the cross product of x and y.
@ -53,7 +53,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cross.xml">GLSL cross man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> cross(vec<3, T, P> const & x, vec<3, T, P> const & y);
/// Returns a vector in the same direction as x but with length of 1.
@ -64,7 +64,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/normalize.xml">GLSL normalize man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> normalize(vec<L, T, P> const& x);
/// If dot(Nref, I) < 0.0, return N, otherwise, return -N.
@ -74,7 +74,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/faceforward.xml">GLSL faceforward man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> faceforward(
vec<L, T, P> const& N,
vec<L, T, P> const& I,
@ -88,7 +88,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/reflect.xml">GLSL reflect man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> reflect(
vec<L, T, P> const& I,
vec<L, T, P> const& N);
@ -102,7 +102,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/refract.xml">GLSL refract man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> refract(
vec<L, T, P> const& I,
vec<L, T, P> const& N,

40
glm/detail/func_geometric.inl
View File

@ -10,7 +10,7 @@
namespace glm{
namespace detail
{
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_length
{
GLM_FUNC_QUALIFIER static T call(vec<L, T, P> const& v)
@ -19,7 +19,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_distance
{
GLM_FUNC_QUALIFIER static T call(vec<L, T, P> const& p0, vec<L, T, P> const& p1)
@ -31,7 +31,7 @@ namespace detail
template<typename V, typename T, bool Aligned>
struct compute_dot{};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_dot<vec<1, T, P>, T, Aligned>
{
GLM_FUNC_QUALIFIER static T call(vec<1, T, P> const& a, vec<1, T, P> const& b)
@ -40,7 +40,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_dot<vec<2, T, P>, T, Aligned>
{
GLM_FUNC_QUALIFIER static T call(vec<2, T, P> const& a, vec<2, T, P> const& b)
@ -50,7 +50,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_dot<vec<3, T, P>, T, Aligned>
{
GLM_FUNC_QUALIFIER static T call(vec<3, T, P> const& a, vec<3, T, P> const& b)
@ -60,7 +60,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_dot<vec<4, T, P>, T, Aligned>
{
GLM_FUNC_QUALIFIER static T call(vec<4, T, P> const& a, vec<4, T, P> const& b)
@ -70,7 +70,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_cross
{
GLM_FUNC_QUALIFIER static vec<3, T, P> call(vec<3, T, P> const& x, vec<3, T, P> const& y)
@ -84,7 +84,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_normalize
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& v)
@ -95,7 +95,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_faceforward
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& N, vec<L, T, P> const& I, vec<L, T, P> const& Nref)
@ -106,7 +106,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_reflect
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& I, vec<L, T, P> const& N)
@ -115,7 +115,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_refract
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& I, vec<L, T, P> const& N, T eta)
@ -136,7 +136,7 @@ namespace detail
return abs(x);
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER T length(vec<L, T, P> const& v)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' accepts only floating-point inputs");
@ -153,7 +153,7 @@ namespace detail
return length(p1 - p0);
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER T distance(vec<L, T, P> const& p0, vec<L, T, P> const& p1)
{
return detail::compute_distance<L, T, P, detail::is_aligned<P>::value>::call(p0, p1);
@ -167,14 +167,14 @@ namespace detail
return x * y;
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER T dot(vec<L, T, P> const& x, vec<L, T, P> const& y)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' accepts only floating-point inputs");
return detail::compute_dot<vec<L, T, P>, T, detail::is_aligned<P>::value>::call(x, y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T dot(tquat<T, P> const& x, tquat<T, P> const& y)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' accepts only floating-point inputs");
@ -182,7 +182,7 @@ namespace detail
}
// cross
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> cross(vec<3, T, P> const& x, vec<3, T, P> const& y)
{
return detail::compute_cross<T, P, detail::is_aligned<P>::value>::call(x, y);
@ -197,7 +197,7 @@ namespace detail
return x < genType(0) ? genType(-1) : genType(1);
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> normalize(vec<L, T, P> const& x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");
@ -212,7 +212,7 @@ namespace detail
return dot(Nref, I) < static_cast<genType>(0) ? N : -N;
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> faceforward(vec<L, T, P> const& N, vec<L, T, P> const& I, vec<L, T, P> const& Nref)
{
return detail::compute_faceforward<L, T, P, detail::is_aligned<P>::value>::call(N, I, Nref);
@ -225,7 +225,7 @@ namespace detail
return I - N * dot(N, I) * genType(2);
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> reflect(vec<L, T, P> const& I, vec<L, T, P> const& N)
{
return detail::compute_reflect<L, T, P, detail::is_aligned<P>::value>::call(I, N);
@ -241,7 +241,7 @@ namespace detail
return (eta * I - (eta * dotValue + sqrt(k)) * N) * static_cast<genType>(k >= static_cast<genType>(0));
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> refract(vec<L, T, P> const& I, vec<L, T, P> const& N, T eta)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'refract' accepts only floating-point inputs");

16
glm/detail/func_geometric_simd.inl
View File

@ -8,7 +8,7 @@
namespace glm{
namespace detail
{
template<precision P>
template<qualifier P>
struct compute_length<4, float, P, true>
{
GLM_FUNC_QUALIFIER static float call(vec<4, float, P> const & v)
@ -17,7 +17,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_distance<4, float, P, true>
{
GLM_FUNC_QUALIFIER static float call(vec<4, float, P> const & p0, vec<4, float, P> const & p1)
@ -26,7 +26,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_dot<vec<4, float, P>, float, true>
{
GLM_FUNC_QUALIFIER static float call(vec<4, float, P> const& x, vec<4, float, P> const& y)
@ -35,7 +35,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_cross<float, P, true>
{
GLM_FUNC_QUALIFIER static vec<3, float, P> call(vec<3, float, P> const & a, vec<3, float, P> const & b)
@ -50,7 +50,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_normalize<4, float, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const & v)
@ -61,7 +61,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_faceforward<4, float, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const& N, vec<4, float, P> const& I, vec<4, float, P> const& Nref)
@ -72,7 +72,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_reflect<4, float, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const& I, vec<4, float, P> const& N)
@ -83,7 +83,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_refract<4, float, P, true>
{
GLM_FUNC_QUALIFIER static vec<4, float, P> call(vec<4, float, P> const& I, vec<4, float, P> const& N, float eta)

22
glm/detail/func_integer.hpp
View File

@ -13,7 +13,7 @@
#pragma once
#include "setup.hpp"
#include "precision.hpp"
#include "qualifier.hpp"
#include "func_common.hpp"
#include "func_vector_relational.hpp"
@ -30,7 +30,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uaddCarry.xml">GLSL uaddCarry man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template<length_t L, precision P>
template<length_t L, qualifier P>
GLM_FUNC_DECL vec<L, uint, P> uaddCarry(
vec<L, uint, P> const & x,
vec<L, uint, P> const & y,
@ -44,7 +44,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/usubBorrow.xml">GLSL usubBorrow man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template<length_t L, precision P>
template<length_t L, qualifier P>
GLM_FUNC_DECL vec<L, uint, P> usubBorrow(
vec<L, uint, P> const & x,
vec<L, uint, P> const & y,
@ -58,7 +58,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/umulExtended.xml">GLSL umulExtended man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template<length_t L, precision P>
template<length_t L, qualifier P>
GLM_FUNC_DECL void umulExtended(
vec<L, uint, P> const & x,
vec<L, uint, P> const & y,
@ -73,7 +73,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/imulExtended.xml">GLSL imulExtended man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template<length_t L, precision P>
template<length_t L, qualifier P>
GLM_FUNC_DECL void imulExtended(
vec<L, int, P> const & x,
vec<L, int, P> const & y,
@ -96,7 +96,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldExtract.xml">GLSL bitfieldExtract man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> bitfieldExtract(
vec<L, T, P> const& Value,
int Offset,
@ -117,7 +117,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldInsert.xml">GLSL bitfieldInsert man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> bitfieldInsert(
vec<L, T, P> const& Base,
vec<L, T, P> const& Insert,
@ -133,7 +133,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldReverse.xml">GLSL bitfieldReverse man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> bitfieldReverse(vec<L, T, P> const & v);
/// Returns the number of bits set to 1 in the binary representation of value.
@ -152,7 +152,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, int, P> bitCount(vec<L, T, P> const & v);
/// Returns the bit number of the least significant bit set to
@ -175,7 +175,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, int, P> findLSB(vec<L, T, P> const & v);
/// Returns the bit number of the most significant bit in the binary representation of value.
@ -200,7 +200,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, int, P> findMSB(vec<L, T, P> const & v);
/// @}

38
glm/detail/func_integer.inl
View File

@ -30,7 +30,7 @@ namespace detail
return Bits >= static_cast<T>(sizeof(T) * 8) ? ~static_cast<T>(0) : (static_cast<T>(1) << Bits) - static_cast<T>(1);
}
template<length_t L, typename T, glm::precision P, bool Aligned, bool EXEC>
template<length_t L, typename T, glm::qualifier P, bool Aligned, bool EXEC>
struct compute_bitfieldReverseStep
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& v, T, T)
@ -39,7 +39,7 @@ namespace detail
}
};
template<length_t L, typename T, glm::precision P, bool Aligned>
template<length_t L, typename T, glm::qualifier P, bool Aligned>
struct compute_bitfieldReverseStep<L, T, P, Aligned, true>
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& v, T Mask, T Shift)
@ -48,7 +48,7 @@ namespace detail
}
};
template<length_t L, typename T, glm::precision P, bool Aligned, bool EXEC>
template<length_t L, typename T, glm::qualifier P, bool Aligned, bool EXEC>
struct compute_bitfieldBitCountStep
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& v, T, T)
@ -57,7 +57,7 @@ namespace detail
}
};
template<length_t L, typename T, glm::precision P, bool Aligned>
template<length_t L, typename T, glm::qualifier P, bool Aligned>
struct compute_bitfieldBitCountStep<L, T, P, Aligned, true>
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& v, T Mask, T Shift)
@ -104,7 +104,7 @@ namespace detail
# endif
# endif//GLM_HAS_BITSCAN_WINDOWS
template<length_t L, typename T, precision P, bool EXEC = true>
template<length_t L, typename T, qualifier P, bool EXEC = true>
struct compute_findMSB_step_vec
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& x, T Shift)
@ -113,7 +113,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
struct compute_findMSB_step_vec<L, T, P, false>
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& x, T)
@ -122,7 +122,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, int>
template<length_t L, typename T, qualifier P, int>
struct compute_findMSB_vec
{
GLM_FUNC_QUALIFIER static vec<L, int, P> call(vec<L, T, P> const& v)
@ -147,7 +147,7 @@ namespace detail
return IsNotNull ? int(Result) : -1;
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
struct compute_findMSB_vec<L, T, P, 32>
{
GLM_FUNC_QUALIFIER static vec<L, int, P> call(vec<L, T, P> const& x)
@ -165,7 +165,7 @@ namespace detail
return IsNotNull ? int(Result) : -1;
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
struct compute_findMSB_vec<L, T, P, 64>
{
GLM_FUNC_QUALIFIER static vec<L, int, P> call(vec<L, T, P> const& x)
@ -186,7 +186,7 @@ namespace detail
return static_cast<uint32>(Value64 % (Max32 + static_cast<uint64>(1)));
}
template<length_t L, precision P>
template<length_t L, qualifier P>
GLM_FUNC_QUALIFIER vec<L, uint, P> uaddCarry(vec<L, uint, P> const& x, vec<L, uint, P> const& y, vec<L, uint, P>& Carry)
{
vec<L, uint64, P> Value64(vec<L, uint64, P>(x) + vec<L, uint64, P>(y));
@ -207,7 +207,7 @@ namespace detail
return static_cast<uint32>((static_cast<int64>(1) << static_cast<int64>(32)) + (static_cast<int64>(y) - static_cast<int64>(x)));
}
template<length_t L, precision P>
template<length_t L, qualifier P>
GLM_FUNC_QUALIFIER vec<L, uint, P> usubBorrow(vec<L, uint, P> const& x, vec<L, uint, P> const& y, vec<L, uint, P>& Borrow)
{
Borrow = mix(vec<L, uint, P>(1), vec<L, uint, P>(0), greaterThanEqual(x, y));
@ -226,7 +226,7 @@ namespace detail
lsb = static_cast<uint>(Value64);
}
template<length_t L, precision P>
template<length_t L, qualifier P>
GLM_FUNC_QUALIFIER void umulExtended(vec<L, uint, P> const& x, vec<L, uint, P> const& y, vec<L, uint, P>& msb, vec<L, uint, P>& lsb)
{
GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch");
@ -246,7 +246,7 @@ namespace detail
lsb = static_cast<int>(Value64);
}
template<length_t L, precision P>
template<length_t L, qualifier P>
GLM_FUNC_QUALIFIER void imulExtended(vec<L, int, P> const& x, vec<L, int, P> const& y, vec<L, int, P>& msb, vec<L, int, P>& lsb)
{
GLM_STATIC_ASSERT(sizeof(int) == sizeof(int32), "int and int32 size mismatch");
@ -263,7 +263,7 @@ namespace detail
return bitfieldExtract(vec<1, genIUType>(Value), Offset, Bits).x;
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> bitfieldExtract(vec<L, T, P> const& Value, int Offset, int Bits)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldExtract' only accept integer inputs");
@ -278,7 +278,7 @@ namespace detail
return bitfieldInsert(vec<1, genIUType>(Base), vec<1, genIUType>(Insert), Offset, Bits).x;
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> bitfieldInsert(vec<L, T, P> const& Base, vec<L, T, P> const& Insert, int Offset, int Bits)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldInsert' only accept integer values");
@ -294,7 +294,7 @@ namespace detail
return bitfieldReverse(glm::vec<1, genType, glm::defaultp>(x)).x;
}
template<length_t L, typename T, glm::precision P>
template<length_t L, typename T, glm::qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> bitfieldReverse(vec<L, T, P> const& v)
{
vec<L, T, P> x(v);
@ -314,7 +314,7 @@ namespace detail
return bitCount(glm::vec<1, genType, glm::defaultp>(x)).x;
}
template<length_t L, typename T, glm::precision P>
template<length_t L, typename T, glm::qualifier P>
GLM_FUNC_QUALIFIER vec<L, int, P> bitCount(vec<L, T, P> const& v)
{
# if GLM_COMPILER & GLM_COMPILER_VC
@ -345,7 +345,7 @@ namespace detail
return detail::compute_findLSB<genIUType, sizeof(genIUType) * 8>::call(Value);
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, int, P> findLSB(vec<L, T, P> const& x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'findLSB' only accept integer values");
@ -362,7 +362,7 @@ namespace detail
return findMSB(vec<1, genIUType>(v)).x;
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, int, P> findMSB(vec<L, T, P> const& v)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'findMSB' only accept integer values");

4
glm/detail/func_integer_simd.inl
View File

@ -8,7 +8,7 @@
namespace glm{
namespace detail
{
template<glm::precision P>
template<glm::qualifier P>
struct compute_bitfieldReverseStep<4, uint32, P, true, true>
{
GLM_FUNC_QUALIFIER static vec<4, uint32, P> call(vec<4, uint32, P> const& v, uint32 Mask, uint32 Shift)
@ -29,7 +29,7 @@ namespace detail
}
};
template<glm::precision P>
template<glm::qualifier P>
struct compute_bitfieldBitCountStep<4, uint32, P, true, true>
{
GLM_FUNC_QUALIFIER static vec<4, uint32, P> call(vec<4, uint32, P> const& v, uint32 Mask, uint32 Shift)

36
glm/detail/func_matrix.hpp
View File

@ -7,15 +7,15 @@
/// @ingroup core
///
/// For each of the following built-in matrix functions, there is both a
/// single-precision floating point version, where all arguments and return values
/// are single precision, and a double-precision floating version, where all
/// arguments and return values are double precision. Only the single-precision
/// single-qualifier floating point version, where all arguments and return values
/// are single qualifier, and a double-qualifier floating version, where all
/// arguments and return values are double qualifier. Only the single-qualifier
/// floating point version is shown.
#pragma once
// Dependencies
#include "../detail/precision.hpp"
#include "../detail/qualifier.hpp"
#include "../detail/setup.hpp"
#include "../detail/type_mat.hpp"
#include "../vec2.hpp"
@ -34,55 +34,55 @@
namespace glm{
namespace detail
{
template<typename T, precision P>
template<typename T, qualifier P>
struct outerProduct_trait<2, 2, T, P>
{
typedef mat<2, 2, T, P> type;
};
template<typename T, precision P>
template<typename T, qualifier P>
struct outerProduct_trait<2, 3, T, P>
{
typedef mat<3, 2, T, P> type;
};
template<typename T, precision P>
template<typename T, qualifier P>
struct outerProduct_trait<2, 4, T, P>
{
typedef mat<4, 2, T, P> type;
};
template<typename T, precision P>
template<typename T, qualifier P>
struct outerProduct_trait<3, 2, T, P>
{
typedef mat<2, 3, T, P> type;
};
template<typename T, precision P>
template<typename T, qualifier P>
struct outerProduct_trait<3, 3, T, P>
{
typedef mat<3, 3, T, P> type;
};
template<typename T, precision P>
template<typename T, qualifier P>
struct outerProduct_trait<3, 4, T, P>
{
typedef mat<4, 3, T, P> type;
};
template<typename T, precision P>
template<typename T, qualifier P>
struct outerProduct_trait<4, 2, T, P>
{
typedef mat<2, 4, T, P> type;
};
template<typename T, precision P>
template<typename T, qualifier P>
struct outerProduct_trait<4, 3, T, P>
{
typedef mat<3, 4, T, P> type;
};
template<typename T, precision P>
template<typename T, qualifier P>
struct outerProduct_trait<4, 4, T, P>
{
typedef mat<4, 4, T, P> type;
@ -100,7 +100,7 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/matrixCompMult.xml">GLSL matrixCompMult man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template<typename T, precision P, template<typename, precision> class matType>
template<typename T, qualifier P, template<typename, qualifier> class matType>
GLM_FUNC_DECL matType<T, P> matrixCompMult(matType<T, P> const & x, matType<T, P> const & y);
/// Treats the first parameter c as a column vector
@ -109,7 +109,7 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/outerProduct.xml">GLSL outerProduct man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template<length_t DA, length_t DB, typename T, precision P>
template<length_t DA, length_t DB, typename T, qualifier P>
GLM_FUNC_DECL typename detail::outerProduct_trait<DA, DB, T, P>::type outerProduct(vec<DA, T, P> const & c, vec<DB, T, P> const & r);
/// Returns the transposed matrix of x
@ -118,7 +118,7 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/transpose.xml">GLSL transpose man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template<typename T, precision P, template<typename, precision> class matType>
template<typename T, qualifier P, template<typename, qualifier> class matType>
GLM_FUNC_DECL typename matType<T, P>::transpose_type transpose(matType<T, P> const & x);
/// Return the determinant of a squared matrix.
@ -127,7 +127,7 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template<typename T, precision P, template<typename, precision> class matType>
template<typename T, qualifier P, template<typename, qualifier> class matType>
GLM_FUNC_DECL T determinant(matType<T, P> const & m);
/// Return the inverse of a squared matrix.
@ -136,7 +136,7 @@ namespace detail
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
template<typename T, precision P, template<typename, precision> class matType>
template<typename T, qualifier P, template<typename, qualifier> class matType>
GLM_FUNC_DECL matType<T, P> inverse(matType<T, P> const & m);
/// @}

48
glm/detail/func_matrix.inl
View File

@ -7,7 +7,7 @@
namespace glm{
namespace detail
{
template<template<length_t, length_t, typename, precision> class matType, length_t C, length_t R, typename T, precision P, bool Aligned>
template<template<length_t, length_t, typename, qualifier> class matType, length_t C, length_t R, typename T, qualifier P, bool Aligned>
struct compute_matrixCompMult
{
GLM_FUNC_QUALIFIER static matType<C, R, T, P> call(matType<C, R, T, P> const& x, matType<C, R, T, P> const& y)
@ -19,10 +19,10 @@ namespace detail
}
};
template<template<length_t, length_t, typename, precision> class matType, length_t C, length_t R, typename T, precision P, bool Aligned>
template<template<length_t, length_t, typename, qualifier> class matType, length_t C, length_t R, typename T, qualifier P, bool Aligned>
struct compute_transpose{};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_transpose<mat, 2, 2, T, P, Aligned>
{
GLM_FUNC_QUALIFIER static mat<2, 2, T, P> call(mat<2, 2, T, P> const& m)
@ -36,7 +36,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_transpose<mat, 2, 3, T, P, Aligned>
{
GLM_FUNC_QUALIFIER static mat<3, 2, T, P> call(mat<2, 3, T, P> const& m)
@ -52,7 +52,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_transpose<mat, 2, 4, T, P, Aligned>
{
GLM_FUNC_QUALIFIER static mat<4, 2, T, P> call(mat<2, 4, T, P> const& m)
@ -70,7 +70,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_transpose<mat, 3, 2, T, P, Aligned>
{
GLM_FUNC_QUALIFIER static mat<2, 3, T, P> call(mat<3, 2, T, P> const& m)
@ -86,7 +86,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_transpose<mat, 3, 3, T, P, Aligned>
{
GLM_FUNC_QUALIFIER static mat<3, 3, T, P> call(mat<3, 3, T, P> const& m)
@ -107,7 +107,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_transpose<mat, 3, 4, T, P, Aligned>
{
GLM_FUNC_QUALIFIER static mat<4, 3, T, P> call(mat<3, 4, T, P> const& m)
@ -129,7 +129,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_transpose<mat, 4, 2, T, P, Aligned>
{
GLM_FUNC_QUALIFIER static mat<2, 4, T, P> call(mat<4, 2, T, P> const& m)
@ -147,7 +147,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_transpose<mat, 4, 3, T, P, Aligned>
{
GLM_FUNC_QUALIFIER static mat<3, 4, T, P> call(mat<4, 3, T, P> const& m)
@ -169,7 +169,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_transpose<mat, 4, 4, T, P, Aligned>
{
GLM_FUNC_QUALIFIER static mat<4, 4, T, P> call(mat<4, 4, T, P> const& m)
@ -198,10 +198,10 @@ namespace detail
}
};
template<template<length_t, length_t, typename, precision> class matType, length_t C, length_t R, typename T, precision P, bool Aligned>
template<template<length_t, length_t, typename, qualifier> class matType, length_t C, length_t R, typename T, qualifier P, bool Aligned>
struct compute_determinant{};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_determinant<mat, 2, 2, T, P, Aligned>
{
GLM_FUNC_QUALIFIER static T call(mat<2, 2, T, P> const& m)
@ -210,7 +210,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_determinant<mat, 3, 3, T, P, Aligned>
{
GLM_FUNC_QUALIFIER static T call(mat<3, 3, T, P> const& m)
@ -222,7 +222,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_determinant<mat, 4, 4, T, P, Aligned>
{
GLM_FUNC_QUALIFIER static T call(mat<4, 4, T, P> const& m)
@ -246,10 +246,10 @@ namespace detail
}
};
template<template<length_t, length_t, typename, precision> class matType, length_t C, length_t R, typename T, precision P, bool Aligned>
template<template<length_t, length_t, typename, qualifier> class matType, length_t C, length_t R, typename T, qualifier P, bool Aligned>
struct compute_inverse{};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_inverse<mat, 2, 2, T, P, Aligned>
{
GLM_FUNC_QUALIFIER static mat<2, 2, T, P> call(mat<2, 2, T, P> const& m)
@ -268,7 +268,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_inverse<mat, 3, 3, T, P, Aligned>
{
GLM_FUNC_QUALIFIER static mat<3, 3, T, P> call(mat<3, 3, T, P> const& m)
@ -293,7 +293,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_inverse<mat, 4, 4, T, P, Aligned>
{
GLM_FUNC_QUALIFIER static mat<4, 4, T, P> call(mat<4, 4, T, P> const& m)
@ -355,14 +355,14 @@ namespace detail
};
}//namespace detail
template<length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
template<length_t C, length_t R, typename T, qualifier P, template<length_t, length_t, typename, qualifier> class matType>
GLM_FUNC_QUALIFIER matType<C, R, T, P> matrixCompMult(matType<C, R, T, P> const & x, matType<C, R, T, P> const & y)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'matrixCompMult' only accept floating-point inputs");
return detail::compute_matrixCompMult<matType, C, R, T, P, detail::is_aligned<P>::value>::call(x, y);
}
template<length_t DA, length_t DB, typename T, precision P>
template<length_t DA, length_t DB, typename T, qualifier P>
GLM_FUNC_QUALIFIER typename detail::outerProduct_trait<DA, DB, T, P>::type outerProduct(vec<DA, T, P> const & c, vec<DB, T, P> const & r)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'outerProduct' only accept floating-point inputs");
@ -373,21 +373,21 @@ namespace detail
return m;
}
template<length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
template<length_t C, length_t R, typename T, qualifier P, template<length_t, length_t, typename, qualifier> class matType>
GLM_FUNC_QUALIFIER typename matType<C, R, T, P>::transpose_type transpose(matType<C, R, T, P> const & m)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'transpose' only accept floating-point inputs");
return detail::compute_transpose<matType, C, R, T, P, detail::is_aligned<P>::value>::call(m);
}
template<length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
template<length_t C, length_t R, typename T, qualifier P, template<length_t, length_t, typename, qualifier> class matType>
GLM_FUNC_QUALIFIER T determinant(matType<C, R, T, P> const & m)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'determinant' only accept floating-point inputs");
return detail::compute_determinant<matType, C, R, T, P, detail::is_aligned<P>::value>::call(m);
}
template<length_t C, length_t R, typename T, precision P, template<length_t, length_t, typename, precision> class matType>
template<length_t C, length_t R, typename T, qualifier P, template<length_t, length_t, typename, qualifier> class matType>
GLM_FUNC_QUALIFIER matType<C, R, T, P> inverse(matType<C, R, T, P> const & m)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'inverse' only accept floating-point inputs");

8
glm/detail/func_matrix_simd.inl
View File

@ -11,7 +11,7 @@
namespace glm{
namespace detail
{
template<precision P>
template<qualifier P>
struct compute_matrixCompMult<mat, 4, 4, float, P, true>
{
GLM_STATIC_ASSERT(detail::is_aligned<P>::value, "Specialization requires aligned");
@ -27,7 +27,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_transpose<mat, 4, 4, float, P, true>
{
GLM_FUNC_QUALIFIER static mat<4, 4, float, P> call(mat<4, 4, float, P> const & m)
@ -40,7 +40,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_determinant<mat, 4, 4, float, P, true>
{
GLM_FUNC_QUALIFIER static float call(mat<4, 4, float, P> const& m)
@ -49,7 +49,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_inverse<mat, 4, 4, float, P, true>
{
GLM_FUNC_QUALIFIER static mat<4, 4, float, P> call(mat<4, 4, float, P> const& m)

2
glm/detail/func_packing.hpp
View File

@ -123,7 +123,7 @@ namespace glm
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
GLM_FUNC_DECL vec4 unpackSnorm4x8(uint p);
/// Returns a double-precision value obtained by packing the components of v into a 64-bit value.
/// Returns a double-qualifier value obtained by packing the components of v into a 64-bit value.
/// If an IEEE 754 Inf or NaN is created, it will not signal, and the resulting floating point value is unspecified.
/// Otherwise, the bit- level representation of v is preserved.
/// The first vector component specifies the 32 least significant bits;

62
glm/detail/func_trigonometric.hpp
View File

@ -15,7 +15,7 @@
#pragma once
#include "setup.hpp"
#include "precision.hpp"
#include "qualifier.hpp"
namespace glm
{
@ -26,22 +26,22 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Enumeration value precision
/// @tparam P Enumeration value qualifier
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/radians.xml">GLSL radians man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, P> radians(vec<L, T, P> const& degrees);
/// Converts radians to degrees and returns the result.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Enumeration value precision
/// @tparam P Enumeration value qualifier
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/degrees.xml">GLSL degrees man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL GLM_CONSTEXPR vec<L, T, P> degrees(vec<L, T, P> const& radians);
/// The standard trigonometric sine function.
@ -49,11 +49,11 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Enumeration value precision
/// @tparam P Enumeration value qualifier
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sin.xml">GLSL sin man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> sin(vec<L, T, P> const& angle);
/// The standard trigonometric cosine function.
@ -61,22 +61,22 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Enumeration value precision
/// @tparam P Enumeration value qualifier
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cos.xml">GLSL cos man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> cos(vec<L, T, P> const& angle);
/// The standard trigonometric tangent function.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Enumeration value precision
/// @tparam P Enumeration value qualifier
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/tan.xml">GLSL tan man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> tan(vec<L, T, P> const& angle);
/// Arc sine. Returns an angle whose sine is x.
@ -85,11 +85,11 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Enumeration value precision
/// @tparam P Enumeration value qualifier
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/asin.xml">GLSL asin man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> asin(vec<L, T, P> const& x);
/// Arc cosine. Returns an angle whose sine is x.
@ -98,11 +98,11 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Enumeration value precision
/// @tparam P Enumeration value qualifier
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/acos.xml">GLSL acos man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> acos(vec<L, T, P> const& x);
/// Arc tangent. Returns an angle whose tangent is y/x.
@ -113,11 +113,11 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Enumeration value precision
/// @tparam P Enumeration value qualifier
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atan.xml">GLSL atan man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> atan(vec<L, T, P> const& y, vec<L, T, P> const& x);
/// Arc tangent. Returns an angle whose tangent is y_over_x.
@ -125,55 +125,55 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Enumeration value precision
/// @tparam P Enumeration value qualifier
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atan.xml">GLSL atan man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> atan(vec<L, T, P> const& y_over_x);
/// Returns the hyperbolic sine function, (exp(x) - exp(-x)) / 2
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Enumeration value precision
/// @tparam P Enumeration value qualifier
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sinh.xml">GLSL sinh man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> sinh(vec<L, T, P> const& angle);
/// Returns the hyperbolic cosine function, (exp(x) + exp(-x)) / 2
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Enumeration value precision
/// @tparam P Enumeration value qualifier
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cosh.xml">GLSL cosh man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> cosh(vec<L, T, P> const& angle);
/// Returns the hyperbolic tangent function, sinh(angle) / cosh(angle)
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Enumeration value precision
/// @tparam P Enumeration value qualifier
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/tanh.xml">GLSL tanh man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> tanh(vec<L, T, P> const& angle);
/// Arc hyperbolic sine; returns the inverse of sinh.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Enumeration value precision
/// @tparam P Enumeration value qualifier
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/asinh.xml">GLSL asinh man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> asinh(vec<L, T, P> const& x);
/// Arc hyperbolic cosine; returns the non-negative inverse
@ -181,11 +181,11 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Enumeration value precision
/// @tparam P Enumeration value qualifier
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/acosh.xml">GLSL acosh man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> acosh(vec<L, T, P> const& x);
/// Arc hyperbolic tangent; returns the inverse of tanh.
@ -193,11 +193,11 @@ namespace glm
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam P Enumeration value precision
/// @tparam P Enumeration value qualifier
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atanh.xml">GLSL atanh man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> atanh(vec<L, T, P> const& x);
/// @}

30
glm/detail/func_trigonometric.inl
View File

@ -16,7 +16,7 @@ namespace glm
return degrees * static_cast<genType>(0.01745329251994329576923690768489);
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, P> radians(vec<L, T, P> const& v)
{
return detail::functor1<L, T, T, P>::call(radians, v);
@ -31,7 +31,7 @@ namespace glm
return radians * static_cast<genType>(57.295779513082320876798154814105);
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<L, T, P> degrees(vec<L, T, P> const& v)
{
return detail::functor1<L, T, T, P>::call(degrees, v);
@ -40,7 +40,7 @@ namespace glm
// sin
using ::std::sin;
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> sin(vec<L, T, P> const& v)
{
return detail::functor1<L, T, T, P>::call(sin, v);
@ -49,7 +49,7 @@ namespace glm
// cos
using std::cos;
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> cos(vec<L, T, P> const& v)
{
return detail::functor1<L, T, T, P>::call(cos, v);
@ -58,7 +58,7 @@ namespace glm
// tan
using std::tan;
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> tan(vec<L, T, P> const& v)
{
return detail::functor1<L, T, T, P>::call(tan, v);
@ -67,7 +67,7 @@ namespace glm
// asin
using std::asin;
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> asin(vec<L, T, P> const& v)
{
return detail::functor1<L, T, T, P>::call(asin, v);
@ -76,7 +76,7 @@ namespace glm
// acos
using std::acos;
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> acos(vec<L, T, P> const& v)
{
return detail::functor1<L, T, T, P>::call(acos, v);
@ -91,7 +91,7 @@ namespace glm
return ::std::atan2(y, x);
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> atan(vec<L, T, P> const& a, vec<L, T, P> const& b)
{
return detail::functor2<L, T, P>::call(::std::atan2, a, b);
@ -99,7 +99,7 @@ namespace glm
using std::atan;
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> atan(vec<L, T, P> const& v)
{
return detail::functor1<L, T, T, P>::call(atan, v);
@ -108,7 +108,7 @@ namespace glm
// sinh
using std::sinh;
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> sinh(vec<L, T, P> const& v)
{
return detail::functor1<L, T, T, P>::call(sinh, v);
@ -117,7 +117,7 @@ namespace glm
// cosh
using std::cosh;
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> cosh(vec<L, T, P> const& v)
{
return detail::functor1<L, T, T, P>::call(cosh, v);
@ -126,7 +126,7 @@ namespace glm
// tanh
using std::tanh;
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> tanh(vec<L, T, P> const& v)
{
return detail::functor1<L, T, T, P>::call(tanh, v);
@ -145,7 +145,7 @@ namespace glm
}
# endif
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> asinh(vec<L, T, P> const& v)
{
return detail::functor1<L, T, T, P>::call(asinh, v);
@ -166,7 +166,7 @@ namespace glm
}
# endif
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> acosh(vec<L, T, P> const& v)
{
return detail::functor1<L, T, T, P>::call(acosh, v);
@ -187,7 +187,7 @@ namespace glm
}
# endif
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> atanh(vec<L, T, P> const& v)
{
return detail::functor1<L, T, T, P>::call(atanh, v);

20
glm/detail/func_vector_relational.hpp
View File

@ -15,7 +15,7 @@
#pragma once
#include "precision.hpp"
#include "qualifier.hpp"
#include "setup.hpp"
namespace glm
@ -30,7 +30,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThan.xml">GLSL lessThan man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, bool, P> lessThan(vec<L, T, P> const& x, vec<L, T, P> const& y);
/// Returns the component-wise comparison of result x <= y.
@ -40,7 +40,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThanEqual.xml">GLSL lessThanEqual man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, bool, P> lessThanEqual(vec<L, T, P> const& x, vec<L, T, P> const& y);
/// Returns the component-wise comparison of result x > y.
@ -50,7 +50,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThan.xml">GLSL greaterThan man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, bool, P> greaterThan(vec<L, T, P> const& x, vec<L, T, P> const& y);
/// Returns the component-wise comparison of result x >= y.
@ -60,7 +60,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThanEqual.xml">GLSL greaterThanEqual man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, bool, P> greaterThanEqual(vec<L, T, P> const& x, vec<L, T, P> const& y);
/// Returns the component-wise comparison of result x == y.
@ -70,7 +70,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/equal.xml">GLSL equal man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, bool, P> equal(vec<L, T, P> const& x, vec<L, T, P> const& y);
/// Returns the component-wise comparison of result x != y.
@ -80,7 +80,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/notEqual.xml">GLSL notEqual man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, bool, P> notEqual(vec<L, T, P> const& x, vec<L, T, P> const& y);
/// Returns true if any component of x is true.
@ -89,7 +89,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/any.xml">GLSL any man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template<length_t L, precision P>
template<length_t L, qualifier P>
GLM_FUNC_DECL bool any(vec<L, bool, P> const& v);
/// Returns true if all components of x are true.
@ -98,7 +98,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/all.xml">GLSL all man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template<length_t L, precision P>
template<length_t L, qualifier P>
GLM_FUNC_DECL bool all(vec<L, bool, P> const& v);
/// Returns the component-wise logical complement of x.
@ -108,7 +108,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/not.xml">GLSL not man page</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
template<length_t L, precision P>
template<length_t L, qualifier P>
GLM_FUNC_DECL vec<L, bool, P> not_(vec<L, bool, P> const& v);
/// @}

18
glm/detail/func_vector_relational.inl
View File

@ -5,7 +5,7 @@
namespace glm
{
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, bool, P> lessThan(vec<L, T, P> const& x, vec<L, T, P> const& y)
{
assert(x.length() == y.length());
@ -17,7 +17,7 @@ namespace glm
return Result;
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, bool, P> lessThanEqual(vec<L, T, P> const& x, vec<L, T, P> const& y)
{
assert(x.length() == y.length());
@ -28,7 +28,7 @@ namespace glm
return Result;
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, bool, P> greaterThan(vec<L, T, P> const& x, vec<L, T, P> const& y)
{
assert(x.length() == y.length());
@ -39,7 +39,7 @@ namespace glm
return Result;
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, bool, P> greaterThanEqual(vec<L, T, P> const& x, vec<L, T, P> const& y)
{
assert(x.length() == y.length());
@ -50,7 +50,7 @@ namespace glm
return Result;
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, bool, P> equal(vec<L, T, P> const& x, vec<L, T, P> const& y)
{
assert(x.length() == y.length());
@ -61,7 +61,7 @@ namespace glm
return Result;
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, bool, P> notEqual(vec<L, T, P> const& x, vec<L, T, P> const& y)
{
assert(x.length() == y.length());
@ -72,7 +72,7 @@ namespace glm
return Result;
}
template<length_t L, precision P>
template<length_t L, qualifier P>
GLM_FUNC_QUALIFIER bool any(vec<L, bool, P> const& v)
{
bool Result = false;
@ -81,7 +81,7 @@ namespace glm
return Result;
}
template<length_t L, precision P>
template<length_t L, qualifier P>
GLM_FUNC_QUALIFIER bool all(vec<L, bool, P> const& v)
{
bool Result = true;
@ -90,7 +90,7 @@ namespace glm
return Result;
}
template<length_t L, precision P>
template<length_t L, qualifier P>
GLM_FUNC_QUALIFIER vec<L, bool, P> not_(vec<L, bool, P> const& v)
{
vec<L, bool, P> Result;

12
glm/detail/qualifier.hpp
View File

@ -1,5 +1,5 @@
/// @ref core
/// @file glm/detail/precision.hpp
/// @file glm/detail/qualifier.hpp
#pragma once
@ -7,8 +7,8 @@
namespace glm
{
/// enum precision
enum precision
/// Qualify GLM types in term of alignment (packed, aligned) and precision in term of ULPs (lowp, mediump, highp)
enum qualifier
{
packed_highp,
packed_mediump,
@ -33,12 +33,12 @@ namespace glm
# endif
};
template<length_t L, typename T, precision P = defaultp> struct vec;
template<length_t C, length_t R, typename T, precision P = defaultp> struct mat;
template<length_t L, typename T, qualifier P = defaultp> struct vec;
template<length_t C, length_t R, typename T, qualifier P = defaultp> struct mat;
namespace detail
{
template<glm::precision P>
template<glm::qualifier P>
struct is_aligned
{
static const bool value = false;

12
glm/detail/type_float.hpp
View File

@ -19,22 +19,22 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// Low precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// Low qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.4 Floats</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef lowp_float_t lowp_float;
/// Medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// Medium qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.4 Floats</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mediump_float_t mediump_float;
/// High precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// High qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.4 Floats</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>

24
glm/detail/type_int.hpp
View File

@ -216,43 +216,43 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// Low precision signed integer.
/// There is no guarantee on the actual precision.
/// Low qualifier signed integer.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::lowp_int_t lowp_int;
/// Medium precision signed integer.
/// There is no guarantee on the actual precision.
/// Medium qualifier signed integer.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::mediump_int_t mediump_int;
/// High precision signed integer.
/// There is no guarantee on the actual precision.
/// High qualifier signed integer.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::highp_int_t highp_int;
/// Low precision unsigned integer.
/// There is no guarantee on the actual precision.
/// Low qualifier unsigned integer.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::lowp_uint_t lowp_uint;
/// Medium precision unsigned integer.
/// There is no guarantee on the actual precision.
/// Medium qualifier unsigned integer.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef detail::mediump_uint_t mediump_uint;
/// High precision unsigned integer.
/// There is no guarantee on the actual precision.
/// High qualifier unsigned integer.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.3 Integers</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>

264
glm/detail/type_mat.hpp
View File

@ -3,70 +3,70 @@
#pragma once
#include "precision.hpp"
#include "qualifier.hpp"
namespace glm{
namespace detail
{
template<length_t Columns, length_t Rows, typename T, precision P>
template<length_t Columns, length_t Rows, typename T, qualifier P>
struct outerProduct_trait{};
}//namespace detail
#if GLM_HAS_TEMPLATE_ALIASES
template <typename T, precision P = defaultp> using tmat2x2 = mat<2, 2, T, P>;
template <typename T, precision P = defaultp> using tmat2x3 = mat<2, 3, T, P>;
template <typename T, precision P = defaultp> using tmat2x4 = mat<2, 4, T, P>;
template <typename T, precision P = defaultp> using tmat3x2 = mat<3, 2, T, P>;
template <typename T, precision P = defaultp> using tmat3x3 = mat<3, 3, T, P>;
template <typename T, precision P = defaultp> using tmat3x4 = mat<3, 4, T, P>;
template <typename T, precision P = defaultp> using tmat4x2 = mat<4, 2, T, P>;
template <typename T, precision P = defaultp> using tmat4x3 = mat<4, 3, T, P>;
template <typename T, precision P = defaultp> using tmat4x4 = mat<4, 4, T, P>;
template <typename T, qualifier P = defaultp> using tmat2x2 = mat<2, 2, T, P>;
template <typename T, qualifier P = defaultp> using tmat2x3 = mat<2, 3, T, P>;
template <typename T, qualifier P = defaultp> using tmat2x4 = mat<2, 4, T, P>;
template <typename T, qualifier P = defaultp> using tmat3x2 = mat<3, 2, T, P>;
template <typename T, qualifier P = defaultp> using tmat3x3 = mat<3, 3, T, P>;
template <typename T, qualifier P = defaultp> using tmat3x4 = mat<3, 4, T, P>;
template <typename T, qualifier P = defaultp> using tmat4x2 = mat<4, 2, T, P>;
template <typename T, qualifier P = defaultp> using tmat4x3 = mat<4, 3, T, P>;
template <typename T, qualifier P = defaultp> using tmat4x4 = mat<4, 4, T, P>;
#endif//GLM_HAS_TEMPLATE_ALIASES
template<typename T, precision P, template<typename, precision> class matType>
template<typename T, qualifier P, template<typename, qualifier> class matType>
GLM_FUNC_DECL matType<T, P> inverse(matType<T, P> const & m);
/// @addtogroup core_precision
/// @{
/// 2 columns of 2 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 columns of 2 components matrix of low qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 2, float, lowp> lowp_mat2;
/// 2 columns of 2 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 columns of 2 components matrix of medium qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 2, float, mediump> mediump_mat2;
/// 2 columns of 2 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 columns of 2 components matrix of high qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 2, float, highp> highp_mat2;
/// 2 columns of 2 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 columns of 2 components matrix of low qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 2, float, lowp> lowp_mat2x2;
/// 2 columns of 2 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 columns of 2 components matrix of medium qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 2, float, mediump> mediump_mat2x2;
/// 2 columns of 2 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 columns of 2 components matrix of high qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
@ -77,22 +77,22 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// 2 columns of 3 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 columns of 3 components matrix of low qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 3, float, lowp> lowp_mat2x3;
/// 2 columns of 3 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 columns of 3 components matrix of medium qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 3, float, mediump> mediump_mat2x3;
/// 2 columns of 3 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 columns of 3 components matrix of high qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
@ -103,22 +103,22 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// 2 columns of 4 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 columns of 4 components matrix of low qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 4, float, lowp> lowp_mat2x4;
/// 2 columns of 4 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 columns of 4 components matrix of medium qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 4, float, mediump> mediump_mat2x4;
/// 2 columns of 4 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 columns of 4 components matrix of high qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
@ -129,22 +129,22 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// 3 columns of 2 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 columns of 2 components matrix of low qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 2, float, lowp> lowp_mat3x2;
/// 3 columns of 2 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 columns of 2 components matrix of medium qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 2, float, mediump> mediump_mat3x2;
/// 3 columns of 2 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 columns of 2 components matrix of high qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
@ -155,43 +155,43 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// 3 columns of 3 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 columns of 3 components matrix of low qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 3, float, lowp> lowp_mat3;
/// 3 columns of 3 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 columns of 3 components matrix of medium qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 3, float, mediump> mediump_mat3;
/// 3 columns of 3 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 columns of 3 components matrix of high qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 3, float, highp> highp_mat3;
/// 3 columns of 3 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 columns of 3 components matrix of low qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 3, float, lowp> lowp_mat3x3;
/// 3 columns of 3 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 columns of 3 components matrix of medium qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 3, float, mediump> mediump_mat3x3;
/// 3 columns of 3 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 columns of 3 components matrix of high qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
@ -202,22 +202,22 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// 3 columns of 4 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 columns of 4 components matrix of low qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 4, float, lowp> lowp_mat3x4;
/// 3 columns of 4 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 columns of 4 components matrix of medium qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 4, float, mediump> mediump_mat3x4;
/// 3 columns of 4 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 columns of 4 components matrix of high qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
@ -228,22 +228,22 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// 4 columns of 2 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 4 columns of 2 components matrix of low qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 2, float, lowp> lowp_mat4x2;
/// 4 columns of 2 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 4 columns of 2 components matrix of medium qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 2, float, mediump> mediump_mat4x2;
/// 4 columns of 2 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 4 columns of 2 components matrix of high qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
@ -254,22 +254,22 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// 4 columns of 3 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 4 columns of 3 components matrix of low qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 3, float, lowp> lowp_mat4x3;
/// 4 columns of 3 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 4 columns of 3 components matrix of medium qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 3, float, mediump> mediump_mat4x3;
/// 4 columns of 3 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 4 columns of 3 components matrix of high qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
@ -281,43 +281,43 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// 4 columns of 4 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 4 columns of 4 components matrix of low qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 4, float, lowp> lowp_mat4;
/// 4 columns of 4 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 4 columns of 4 components matrix of medium qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 4, float, mediump> mediump_mat4;
/// 4 columns of 4 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 4 columns of 4 components matrix of high qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 4, float, highp> highp_mat4;
/// 4 columns of 4 components matrix of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 4 columns of 4 components matrix of low qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 4, float, lowp> lowp_mat4x4;
/// 4 columns of 4 components matrix of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 4 columns of 4 components matrix of medium qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 4, float, mediump> mediump_mat4x4;
/// 4 columns of 4 components matrix of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 4 columns of 4 components matrix of high qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
@ -420,37 +420,37 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// 2 columns of 2 components matrix of low precision floating-point numbers.
/// 2 columns of 2 components matrix of low qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 2, double, lowp> lowp_dmat2;
/// 2 columns of 2 components matrix of medium precision floating-point numbers.
/// 2 columns of 2 components matrix of medium qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 2, double, mediump> mediump_dmat2;
/// 2 columns of 2 components matrix of high precision floating-point numbers.
/// 2 columns of 2 components matrix of high qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 2, double, highp> highp_dmat2;
/// 2 columns of 2 components matrix of low precision floating-point numbers.
/// 2 columns of 2 components matrix of low qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 2, double, lowp> lowp_dmat2x2;
/// 2 columns of 2 components matrix of medium precision floating-point numbers.
/// 2 columns of 2 components matrix of medium qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 2, double, mediump> mediump_dmat2x2;
/// 2 columns of 2 components matrix of high precision floating-point numbers.
/// 2 columns of 2 components matrix of high qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
@ -461,19 +461,19 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// 2 columns of 3 components matrix of low precision floating-point numbers.
/// 2 columns of 3 components matrix of low qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 3, double, lowp> lowp_dmat2x3;
/// 2 columns of 3 components matrix of medium precision floating-point numbers.
/// 2 columns of 3 components matrix of medium qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 3, double, mediump> mediump_dmat2x3;
/// 2 columns of 3 components matrix of high precision floating-point numbers.
/// 2 columns of 3 components matrix of high qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
@ -484,19 +484,19 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// 2 columns of 4 components matrix of low precision floating-point numbers.
/// 2 columns of 4 components matrix of low qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 4, double, lowp> lowp_dmat2x4;
/// 2 columns of 4 components matrix of medium precision floating-point numbers.
/// 2 columns of 4 components matrix of medium qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<2, 4, double, mediump> mediump_dmat2x4;
/// 2 columns of 4 components matrix of high precision floating-point numbers.
/// 2 columns of 4 components matrix of high qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
@ -507,19 +507,19 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// 3 columns of 2 components matrix of low precision floating-point numbers.
/// 3 columns of 2 components matrix of low qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 2, double, lowp> lowp_dmat3x2;
/// 3 columns of 2 components matrix of medium precision floating-point numbers.
/// 3 columns of 2 components matrix of medium qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 2, double, mediump> mediump_dmat3x2;
/// 3 columns of 2 components matrix of high precision floating-point numbers.
/// 3 columns of 2 components matrix of high qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
@ -530,37 +530,37 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// 3 columns of 3 components matrix of low precision floating-point numbers.
/// 3 columns of 3 components matrix of low qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 3, float, lowp> lowp_dmat3;
/// 3 columns of 3 components matrix of medium precision floating-point numbers.
/// 3 columns of 3 components matrix of medium qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 3, double, mediump> mediump_dmat3;
/// 3 columns of 3 components matrix of high precision floating-point numbers.
/// 3 columns of 3 components matrix of high qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 3, double, highp> highp_dmat3;
/// 3 columns of 3 components matrix of low precision floating-point numbers.
/// 3 columns of 3 components matrix of low qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 3, double, lowp> lowp_dmat3x3;
/// 3 columns of 3 components matrix of medium precision floating-point numbers.
/// 3 columns of 3 components matrix of medium qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 3, double, mediump> mediump_dmat3x3;
/// 3 columns of 3 components matrix of high precision floating-point numbers.
/// 3 columns of 3 components matrix of high qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
@ -571,19 +571,19 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// 3 columns of 4 components matrix of low precision floating-point numbers.
/// 3 columns of 4 components matrix of low qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 4, double, lowp> lowp_dmat3x4;
/// 3 columns of 4 components matrix of medium precision floating-point numbers.
/// 3 columns of 4 components matrix of medium qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<3, 4, double, mediump> mediump_dmat3x4;
/// 3 columns of 4 components matrix of high precision floating-point numbers.
/// 3 columns of 4 components matrix of high qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
@ -594,19 +594,19 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// 4 columns of 2 components matrix of low precision floating-point numbers.
/// 4 columns of 2 components matrix of low qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 2, double, lowp> lowp_dmat4x2;
/// 4 columns of 2 components matrix of medium precision floating-point numbers.
/// 4 columns of 2 components matrix of medium qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 2, double, mediump> mediump_dmat4x2;
/// 4 columns of 2 components matrix of high precision floating-point numbers.
/// 4 columns of 2 components matrix of high qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
@ -617,19 +617,19 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// 4 columns of 3 components matrix of low precision floating-point numbers.
/// 4 columns of 3 components matrix of low qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 3, double, lowp> lowp_dmat4x3;
/// 4 columns of 3 components matrix of medium precision floating-point numbers.
/// 4 columns of 3 components matrix of medium qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 3, double, mediump> mediump_dmat4x3;
/// 4 columns of 3 components matrix of high precision floating-point numbers.
/// 4 columns of 3 components matrix of high qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
@ -640,37 +640,37 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// 4 columns of 4 components matrix of low precision floating-point numbers.
/// 4 columns of 4 components matrix of low qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 4, double, lowp> lowp_dmat4;
/// 4 columns of 4 components matrix of medium precision floating-point numbers.
/// 4 columns of 4 components matrix of medium qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 4, double, mediump> mediump_dmat4;
/// 4 columns of 4 components matrix of high precision floating-point numbers.
/// 4 columns of 4 components matrix of high qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 4, double, highp> highp_dmat4;
/// 4 columns of 4 components matrix of low precision floating-point numbers.
/// 4 columns of 4 components matrix of low qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 4, double, lowp> lowp_dmat4x4;
/// 4 columns of 4 components matrix of medium precision floating-point numbers.
/// 4 columns of 4 components matrix of medium qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef mat<4, 4, double, mediump> mediump_dmat4x4;
/// 4 columns of 4 components matrix of high precision floating-point numbers.
/// 4 columns of 4 components matrix of high qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
@ -700,62 +700,62 @@ namespace detail
typedef mediump_dmat4x4 dmat4x4;
#else //defined(GLM_PRECISION_HIGHP_DOUBLE)
//! 2 * 2 matrix of double-precision floating-point numbers.
//! 2 * 2 matrix of double-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef highp_dmat2x2 dmat2;
//! 3 * 3 matrix of double-precision floating-point numbers.
//! 3 * 3 matrix of double-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef highp_dmat3x3 dmat3;
//! 4 * 4 matrix of double-precision floating-point numbers.
//! 4 * 4 matrix of double-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef highp_dmat4x4 dmat4;
//! 2 * 2 matrix of double-precision floating-point numbers.
//! 2 * 2 matrix of double-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef highp_dmat2x2 dmat2x2;
//! 2 * 3 matrix of double-precision floating-point numbers.
//! 2 * 3 matrix of double-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef highp_dmat2x3 dmat2x3;
//! 2 * 4 matrix of double-precision floating-point numbers.
//! 2 * 4 matrix of double-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef highp_dmat2x4 dmat2x4;
//! 3 * 2 matrix of double-precision floating-point numbers.
//! 3 * 2 matrix of double-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef highp_dmat3x2 dmat3x2;
/// 3 * 3 matrix of double-precision floating-point numbers.
/// 3 * 3 matrix of double-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef highp_dmat3x3 dmat3x3;
/// 3 * 4 matrix of double-precision floating-point numbers.
/// 3 * 4 matrix of double-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef highp_dmat3x4 dmat3x4;
/// 4 * 2 matrix of double-precision floating-point numbers.
/// 4 * 2 matrix of double-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef highp_dmat4x2 dmat4x2;
/// 4 * 3 matrix of double-precision floating-point numbers.
/// 4 * 3 matrix of double-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef highp_dmat4x3 dmat4x3;
/// 4 * 4 matrix of double-precision floating-point numbers.
/// 4 * 4 matrix of double-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.6 Matrices</a>
typedef highp_dmat4x4 dmat4x4;

50
glm/detail/type_mat2x2.hpp
View File

@ -11,7 +11,7 @@
namespace glm
{
template<typename T, precision P>
template<typename T, qualifier P>
struct mat<2, 2, T, P>
{
typedef vec<2, T, P> col_type;
@ -36,7 +36,7 @@ namespace glm
GLM_FUNC_DECL mat() GLM_DEFAULT;
GLM_FUNC_DECL mat(mat<2, 2, T, P> const & m) GLM_DEFAULT;
template<precision Q>
template<qualifier Q>
GLM_FUNC_DECL mat(mat<2, 2, T, Q> const & m);
GLM_FUNC_DECL explicit mat(T scalar);
@ -61,7 +61,7 @@ namespace glm
// -- Matrix conversions --
template<typename U, precision Q>
template<typename U, qualifier Q>
GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, U, Q> const & m);
GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 3, T, P> const & x);
@ -106,74 +106,74 @@ namespace glm
// -- Unary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 2, T, P> operator+(mat<2, 2, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 2, T, P> operator-(mat<2, 2, T, P> const & m);
// -- Binary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 2, T, P> operator+(mat<2, 2, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 2, T, P> operator+(T scalar, mat<2, 2, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 2, T, P> operator+(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 2, T, P> operator-(mat<2, 2, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 2, T, P> operator-(T scalar, mat<2, 2, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 2, T, P> operator-(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 2, T, P> operator*(mat<2, 2, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 2, T, P> operator*(T scalar, mat<2, 2, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<2, 2, T, P>::col_type operator*(mat<2, 2, T, P> const & m, typename mat<2, 2, T, P>::row_type const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<2, 2, T, P>::row_type operator*(typename mat<2, 2, T, P>::col_type const & v, mat<2, 2, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 2, T, P> operator*(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 2, T, P> operator*(mat<2, 2, T, P> const & m1, mat<3, 2, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 2, T, P> operator*(mat<2, 2, T, P> const & m1, mat<4, 2, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 2, T, P> operator/(mat<2, 2, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 2, T, P> operator/(T scalar, mat<2, 2, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<2, 2, T, P>::col_type operator/(mat<2, 2, T, P> const & m, typename mat<2, 2, T, P>::row_type const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<2, 2, T, P>::row_type operator/(typename mat<2, 2, T, P>::col_type const & v, mat<2, 2, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 2, T, P> operator/(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2);
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator==(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator!=(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2);
} //namespace glm

114
glm/detail/type_mat2x2.inl
View File

@ -8,13 +8,13 @@ namespace glm
// -- Constructors --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat()
{}
# endif
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<2, 2, T, P> const& m)
{
this->value[0] = m.value[0];
@ -22,22 +22,22 @@ namespace glm
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<precision Q>
template<typename T, qualifier P>
template<qualifier Q>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<2, 2, T, Q> const& m)
{
this->value[0] = m.value[0];
this->value[1] = m.value[1];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(T scalar)
{
this->value[0] = col_type(scalar, 0);
this->value[1] = col_type(0, scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat
(
T const & x0, T const & y0,
@ -48,7 +48,7 @@ namespace glm
this->value[1] = col_type(x1, y1);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(col_type const& v0, col_type const& v1)
{
this->value[0] = v0;
@ -57,7 +57,7 @@ namespace glm
// -- Conversion constructors --
template<typename T, precision P>
template<typename T, qualifier P>
template<typename X1, typename Y1, typename X2, typename Y2>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat
(
@ -69,7 +69,7 @@ namespace glm
this->value[1] = col_type(static_cast<T>(x2), value_type(y2));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename V1, typename V2>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(vec<2, V1, P> const& v1, vec<2, V2, P> const& v2)
{
@ -79,64 +79,64 @@ namespace glm
// -- mat2x2 matrix conversions --
template<typename T, precision P>
template<typename U, precision Q>
template<typename T, qualifier P>
template<typename U, qualifier Q>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<2, 2, U, Q> const& m)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<3, 3, T, P> const& m)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<4, 4, T, P> const& m)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<2, 3, T, P> const& m)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<3, 2, T, P> const& m)
{
this->value[0] = m[0];
this->value[1] = m[1];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<2, 4, T, P> const& m)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<4, 2, T, P> const& m)
{
this->value[0] = m[0];
this->value[1] = m[1];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<3, 4, T, P> const& m)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>::mat(mat<4, 3, T, P> const& m)
{
this->value[0] = col_type(m[0]);
@ -145,14 +145,14 @@ namespace glm
// -- Accesses --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<2, 2, T, P>::col_type& mat<2, 2, T, P>::operator[](typename mat<2, 2, T, P>::length_type i)
{
assert(i < this->length());
return this->value[i];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<2, 2, T, P>::col_type const& mat<2, 2, T, P>::operator[](typename mat<2, 2, T, P>::length_type i) const
{
assert(i < this->length());
@ -162,7 +162,7 @@ namespace glm
// -- Unary updatable operators --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator=(mat<2, 2, T, P> const & m)
{
this->value[0] = m[0];
@ -171,7 +171,7 @@ namespace glm
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator=(mat<2, 2, U, P> const & m)
{
@ -180,7 +180,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator+=(U scalar)
{
@ -189,7 +189,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator+=(mat<2, 2, U, P> const & m)
{
@ -198,7 +198,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator-=(U scalar)
{
@ -207,7 +207,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator-=(mat<2, 2, U, P> const & m)
{
@ -216,7 +216,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator*=(U scalar)
{
@ -225,14 +225,14 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator*=(mat<2, 2, U, P> const & m)
{
return (*this = *this * m);
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator/=(U scalar)
{
@ -241,7 +241,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator/=(mat<2, 2, U, P> const & m)
{
@ -250,7 +250,7 @@ namespace glm
// -- Increment and decrement operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator++()
{
++this->value[0];
@ -258,7 +258,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P>& mat<2, 2, T, P>::operator--()
{
--this->value[0];
@ -266,7 +266,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P> mat<2, 2, T, P>::operator++(int)
{
mat<2, 2, T, P> Result(*this);
@ -274,7 +274,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P> mat<2, 2, T, P>::operator--(int)
{
mat<2, 2, T, P> Result(*this);
@ -284,13 +284,13 @@ namespace glm
// -- Unary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator+(mat<2, 2, T, P> const & m)
{
return m;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator-(mat<2, 2, T, P> const & m)
{
return mat<2, 2, T, P>(
@ -300,7 +300,7 @@ namespace glm
// -- Binary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator+(mat<2, 2, T, P> const & m, T scalar)
{
return mat<2, 2, T, P>(
@ -308,7 +308,7 @@ namespace glm
m[1] + scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator+(T scalar, mat<2, 2, T, P> const & m)
{
return mat<2, 2, T, P>(
@ -316,7 +316,7 @@ namespace glm
m[1] + scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator+(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2)
{
return mat<2, 2, T, P>(
@ -324,7 +324,7 @@ namespace glm
m1[1] + m2[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator-(mat<2, 2, T, P> const & m, T scalar)
{
return mat<2, 2, T, P>(
@ -332,7 +332,7 @@ namespace glm
m[1] - scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator-(T scalar, mat<2, 2, T, P> const & m)
{
return mat<2, 2, T, P>(
@ -340,7 +340,7 @@ namespace glm
scalar - m[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator-(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2)
{
return mat<2, 2, T, P>(
@ -348,7 +348,7 @@ namespace glm
m1[1] - m2[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator*(mat<2, 2, T, P> const & m, T scalar)
{
return mat<2, 2, T, P>(
@ -356,7 +356,7 @@ namespace glm
m[1] * scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator*(T scalar, mat<2, 2, T, P> const & m)
{
return mat<2, 2, T, P>(
@ -364,7 +364,7 @@ namespace glm
m[1] * scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<2, 2, T, P>::col_type operator*
(
mat<2, 2, T, P> const& m,
@ -376,7 +376,7 @@ namespace glm
m[0][1] * v.x + m[1][1] * v.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<2, 2, T, P>::row_type operator*
(
typename mat<2, 2, T, P>::col_type const & v,
@ -388,7 +388,7 @@ namespace glm
v.x * m[1][0] + v.y * m[1][1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator*(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2)
{
return mat<2, 2, T, P>(
@ -398,7 +398,7 @@ namespace glm
m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator*(mat<2, 2, T, P> const & m1, mat<3, 2, T, P> const & m2)
{
return mat<3, 2, T, P>(
@ -410,7 +410,7 @@ namespace glm
m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator*(mat<2, 2, T, P> const & m1, mat<4, 2, T, P> const & m2)
{
return mat<4, 2, T, P>(
@ -424,7 +424,7 @@ namespace glm
m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator/(mat<2, 2, T, P> const & m, T scalar)
{
return mat<2, 2, T, P>(
@ -432,7 +432,7 @@ namespace glm
m[1] / scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator/(T scalar, mat<2, 2, T, P> const & m)
{
return mat<2, 2, T, P>(
@ -440,19 +440,19 @@ namespace glm
scalar / m[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<2, 2, T, P>::col_type operator/(mat<2, 2, T, P> const & m, typename mat<2, 2, T, P>::row_type const & v)
{
return inverse(m) * v;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<2, 2, T, P>::row_type operator/(typename mat<2, 2, T, P>::col_type const & v, mat<2, 2, T, P> const & m)
{
return v * inverse(m);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator/(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2)
{
mat<2, 2, T, P> m1_copy(m1);
@ -461,13 +461,13 @@ namespace glm
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator==(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2)
{
return (m1[0] == m2[0]) && (m1[1] == m2[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator!=(mat<2, 2, T, P> const & m1, mat<2, 2, T, P> const & m2)
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]);

40
glm/detail/type_mat2x3.hpp
View File

@ -12,7 +12,7 @@
namespace glm
{
template<typename T, precision P>
template<typename T, qualifier P>
struct mat<2, 3, T, P>
{
typedef vec<3, T, P> col_type;
@ -37,7 +37,7 @@ namespace glm
GLM_FUNC_DECL mat() GLM_DEFAULT;
GLM_FUNC_DECL mat(mat<2, 3, T, P> const & m) GLM_DEFAULT;
template<precision Q>
template<qualifier Q>
GLM_FUNC_DECL mat(mat<2, 3, T, Q> const & m);
GLM_FUNC_DECL explicit mat(T scalar);
@ -62,7 +62,7 @@ namespace glm
// -- Matrix conversions --
template<typename U, precision Q>
template<typename U, qualifier Q>
GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 3, U, Q> const & m);
GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x);
@ -103,59 +103,59 @@ namespace glm
// -- Unary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 3, T, P> operator+(mat<2, 3, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 3, T, P> operator-(mat<2, 3, T, P> const & m);
// -- Binary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 3, T, P> operator+(mat<2, 3, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 3, T, P> operator+(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 3, T, P> operator-(mat<2, 3, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 3, T, P> operator-(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 3, T, P> operator*(mat<2, 3, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 3, T, P> operator*(T scalar, mat<2, 3, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<2, 3, T, P>::col_type operator*(mat<2, 3, T, P> const & m, typename mat<2, 3, T, P>::row_type const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<2, 3, T, P>::row_type operator*(typename mat<2, 3, T, P>::col_type const & v, mat<2, 3, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 3, T, P> operator*(mat<2, 3, T, P> const & m1, mat<2, 2, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 3, T, P> operator*(mat<2, 3, T, P> const & m1, mat<3, 2, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 3, T, P> operator*(mat<2, 3, T, P> const & m1, mat<4, 2, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 3, T, P> operator/(mat<2, 3, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 3, T, P> operator/(T scalar, mat<2, 3, T, P> const & m);
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator==(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator!=(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2);
}//namespace glm

100
glm/detail/type_mat2x3.inl
View File

@ -6,13 +6,13 @@ namespace glm
// -- Constructors --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat()
{}
# endif
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<2, 3, T, P> const & m)
{
this->value[0] = m.value[0];
@ -20,22 +20,22 @@ namespace glm
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<precision Q>
template<typename T, qualifier P>
template<qualifier Q>
GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<2, 3, T, Q> const & m)
{
this->value[0] = m.value[0];
this->value[1] = m.value[1];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(T scalar)
{
this->value[0] = col_type(scalar, 0, 0);
this->value[1] = col_type(0, scalar, 0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat
(
T x0, T y0, T z0,
@ -46,7 +46,7 @@ namespace glm
this->value[1] = col_type(x1, y1, z1);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(col_type const & v0, col_type const & v1)
{
this->value[0] = v0;
@ -55,7 +55,7 @@ namespace glm
// -- Conversion constructors --
template<typename T, precision P>
template<typename T, qualifier P>
template<
typename X1, typename Y1, typename Z1,
typename X2, typename Y2, typename Z2>
@ -69,7 +69,7 @@ namespace glm
this->value[1] = col_type(static_cast<T>(x2), value_type(y2), value_type(z2));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename V1, typename V2>
GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(vec<3, V1, P> const & v1, vec<3, V2, P> const & v2)
{
@ -79,64 +79,64 @@ namespace glm
// -- Matrix conversions --
template<typename T, precision P>
template<typename U, precision Q>
template<typename T, qualifier P>
template<typename U, qualifier Q>
GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<2, 3, U, Q> const & m)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<2, 2, T, P> const & m)
{
this->value[0] = col_type(m[0], 0);
this->value[1] = col_type(m[1], 0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<3, 3, T, P> const & m)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<4, 4, T, P> const & m)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<2, 4, T, P> const & m)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<3, 2, T, P> const & m)
{
this->value[0] = col_type(m[0], 0);
this->value[1] = col_type(m[1], 0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<3, 4, T, P> const & m)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<4, 2, T, P> const & m)
{
this->value[0] = col_type(m[0], 0);
this->value[1] = col_type(m[1], 0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P>::mat(mat<4, 3, T, P> const & m)
{
this->value[0] = m[0];
@ -145,14 +145,14 @@ namespace glm
// -- Accesses --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<2, 3, T, P>::col_type & mat<2, 3, T, P>::operator[](typename mat<2, 3, T, P>::length_type i)
{
assert(i < this->length());
return this->value[i];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<2, 3, T, P>::col_type const & mat<2, 3, T, P>::operator[](typename mat<2, 3, T, P>::length_type i) const
{
assert(i < this->length());
@ -162,7 +162,7 @@ namespace glm
// -- Unary updatable operators --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P>& mat<2, 3, T, P>::operator=(mat<2, 3, T, P> const & m)
{
this->value[0] = m[0];
@ -171,7 +171,7 @@ namespace glm
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 3, T, P>& mat<2, 3, T, P>::operator=(mat<2, 3, U, P> const & m)
{
@ -180,7 +180,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 3, T, P> & mat<2, 3, T, P>::operator+=(U s)
{
@ -189,7 +189,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 3, T, P>& mat<2, 3, T, P>::operator+=(mat<2, 3, U, P> const & m)
{
@ -198,7 +198,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 3, T, P>& mat<2, 3, T, P>::operator-=(U s)
{
@ -207,7 +207,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 3, T, P>& mat<2, 3, T, P>::operator-=(mat<2, 3, U, P> const & m)
{
@ -216,7 +216,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 3, T, P>& mat<2, 3, T, P>::operator*=(U s)
{
@ -225,7 +225,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 3, T, P> & mat<2, 3, T, P>::operator/=(U s)
{
@ -236,7 +236,7 @@ namespace glm
// -- Increment and decrement operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P> & mat<2, 3, T, P>::operator++()
{
++this->value[0];
@ -244,7 +244,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P> & mat<2, 3, T, P>::operator--()
{
--this->value[0];
@ -252,7 +252,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P> mat<2, 3, T, P>::operator++(int)
{
mat<2, 3, T, P> Result(*this);
@ -260,7 +260,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P> mat<2, 3, T, P>::operator--(int)
{
mat<2, 3, T, P> Result(*this);
@ -270,13 +270,13 @@ namespace glm
// -- Unary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator+(mat<2, 3, T, P> const & m)
{
return m;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator-(mat<2, 3, T, P> const & m)
{
return mat<2, 3, T, P>(
@ -286,7 +286,7 @@ namespace glm
// -- Binary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator+(mat<2, 3, T, P> const & m, T scalar)
{
return mat<2, 3, T, P>(
@ -294,7 +294,7 @@ namespace glm
m[1] + scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator+(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2)
{
return mat<2, 3, T, P>(
@ -302,7 +302,7 @@ namespace glm
m1[1] + m2[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator-(mat<2, 3, T, P> const & m, T scalar)
{
return mat<2, 3, T, P>(
@ -310,7 +310,7 @@ namespace glm
m[1] - scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator-(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2)
{
return mat<2, 3, T, P>(
@ -318,7 +318,7 @@ namespace glm
m1[1] - m2[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator*(mat<2, 3, T, P> const & m, T scalar)
{
return mat<2, 3, T, P>(
@ -326,7 +326,7 @@ namespace glm
m[1] * scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator*(T scalar, mat<2, 3, T, P> const & m)
{
return mat<2, 3, T, P>(
@ -334,7 +334,7 @@ namespace glm
m[1] * scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<2, 3, T, P>::col_type operator*
(
mat<2, 3, T, P> const& m,
@ -346,7 +346,7 @@ namespace glm
m[0][2] * v.x + m[1][2] * v.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<2, 3, T, P>::row_type operator*
(
typename mat<2, 3, T, P>::col_type const & v,
@ -357,7 +357,7 @@ namespace glm
v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator*(mat<2, 3, T, P> const & m1, mat<2, 2, T, P> const & m2)
{
return mat<2, 3, T, P>(
@ -369,7 +369,7 @@ namespace glm
m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator*(mat<2, 3, T, P> const & m1, mat<3, 2, T, P> const & m2)
{
T SrcA00 = m1[0][0];
@ -399,7 +399,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator*(mat<2, 3, T, P> const & m1, mat<4, 2, T, P> const & m2)
{
return mat<4, 3, T, P>(
@ -417,7 +417,7 @@ namespace glm
m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator/(mat<2, 3, T, P> const & m, T scalar)
{
return mat<2, 3, T, P>(
@ -425,7 +425,7 @@ namespace glm
m[1] / scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator/(T scalar, mat<2, 3, T, P> const & m)
{
return mat<2, 3, T, P>(
@ -435,13 +435,13 @@ namespace glm
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator==(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2)
{
return (m1[0] == m2[0]) && (m1[1] == m2[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator!=(mat<2, 3, T, P> const & m1, mat<2, 3, T, P> const & m2)
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]);

40
glm/detail/type_mat2x4.hpp
View File

@ -12,7 +12,7 @@
namespace glm
{
template<typename T, precision P>
template<typename T, qualifier P>
struct mat<2, 4, T, P>
{
typedef vec<4, T, P> col_type;
@ -37,7 +37,7 @@ namespace glm
GLM_FUNC_DECL mat() GLM_DEFAULT;
GLM_FUNC_DECL mat(mat<2, 4, T, P> const & m) GLM_DEFAULT;
template<precision Q>
template<qualifier Q>
GLM_FUNC_DECL mat(mat<2, 4, T, Q> const & m);
GLM_FUNC_DECL explicit mat(T scalar);
@ -64,7 +64,7 @@ namespace glm
// -- Matrix conversions --
template<typename U, precision Q>
template<typename U, qualifier Q>
GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 4, U, Q> const & m);
GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x);
@ -105,59 +105,59 @@ namespace glm
// -- Unary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 4, T, P> operator+(mat<2, 4, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 4, T, P> operator-(mat<2, 4, T, P> const & m);
// -- Binary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 4, T, P> operator+(mat<2, 4, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 4, T, P> operator+(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 4, T, P> operator-(mat<2, 4, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 4, T, P> operator-(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 4, T, P> operator*(mat<2, 4, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 4, T, P> operator*(T scalar, mat<2, 4, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<2, 4, T, P>::col_type operator*(mat<2, 4, T, P> const & m, typename mat<2, 4, T, P>::row_type const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<2, 4, T, P>::row_type operator*(typename mat<2, 4, T, P>::col_type const & v, mat<2, 4, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> operator*(mat<2, 4, T, P> const & m1, mat<4, 2, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 4, T, P> operator*(mat<2, 4, T, P> const & m1, mat<2, 2, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 4, T, P> operator*(mat<2, 4, T, P> const & m1, mat<3, 2, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 4, T, P> operator/(mat<2, 4, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 4, T, P> operator/(T scalar, mat<2, 4, T, P> const & m);
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator==(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator!=(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2);
}//namespace glm

100
glm/detail/type_mat2x4.inl
View File

@ -6,13 +6,13 @@ namespace glm
// -- Constructors --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat()
{}
# endif
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<2, 4, T, P> const & m)
{
this->value[0] = m.value[0];
@ -20,15 +20,15 @@ namespace glm
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<precision Q>
template<typename T, qualifier P>
template<qualifier Q>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<2, 4, T, Q> const & m)
{
this->value[0] = m.value[0];
this->value[1] = m.value[1];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(T scalar)
{
value_type const Zero(0);
@ -36,7 +36,7 @@ namespace glm
this->value[1] = col_type(Zero, scalar, Zero, Zero);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat
(
T x0, T y0, T z0, T w0,
@ -47,7 +47,7 @@ namespace glm
this->value[1] = col_type(x1, y1, z1, w1);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(col_type const & v0, col_type const & v1)
{
this->value[0] = v0;
@ -56,7 +56,7 @@ namespace glm
// -- Conversion constructors --
template<typename T, precision P>
template<typename T, qualifier P>
template<
typename X1, typename Y1, typename Z1, typename W1,
typename X2, typename Y2, typename Z2, typename W2>
@ -70,7 +70,7 @@ namespace glm
this->value[1] = col_type(static_cast<T>(x2), value_type(y2), value_type(z2), value_type(w2));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename V1, typename V2>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(vec<4, V1, P> const & v1, vec<4, V2, P> const & v2)
{
@ -80,64 +80,64 @@ namespace glm
// -- Matrix conversions --
template<typename T, precision P>
template<typename U, precision Q>
template<typename T, qualifier P>
template<typename U, qualifier Q>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<2, 4, U, Q> const & m)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<2, 2, T, P> const & m)
{
this->value[0] = col_type(m[0], 0, 0);
this->value[1] = col_type(m[1], 0, 0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<3, 3, T, P> const & m)
{
this->value[0] = col_type(m[0], 0);
this->value[1] = col_type(m[1], 0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<4, 4, T, P> const & m)
{
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<2, 3, T, P> const & m)
{
this->value[0] = col_type(m[0], 0);
this->value[1] = col_type(m[1], 0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<3, 2, T, P> const & m)
{
this->value[0] = col_type(m[0], 0, 0);
this->value[1] = col_type(m[1], 0, 0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<3, 4, T, P> const & m)
{
this->value[0] = m[0];
this->value[1] = m[1];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<4, 2, T, P> const & m)
{
this->value[0] = col_type(m[0], 0, 0);
this->value[1] = col_type(m[1], 0, 0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>::mat(mat<4, 3, T, P> const & m)
{
this->value[0] = col_type(m[0], 0);
@ -146,14 +146,14 @@ namespace glm
// -- Accesses --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<2, 4, T, P>::col_type & mat<2, 4, T, P>::operator[](typename mat<2, 4, T, P>::length_type i)
{
assert(i < this->length());
return this->value[i];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<2, 4, T, P>::col_type const & mat<2, 4, T, P>::operator[](typename mat<2, 4, T, P>::length_type i) const
{
assert(i < this->length());
@ -163,7 +163,7 @@ namespace glm
// -- Unary updatable operators --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator=(mat<2, 4, T, P> const & m)
{
this->value[0] = m[0];
@ -172,7 +172,7 @@ namespace glm
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator=(mat<2, 4, U, P> const & m)
{
@ -181,7 +181,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator+=(U s)
{
@ -190,7 +190,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator+=(mat<2, 4, U, P> const & m)
{
@ -199,7 +199,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator-=(U s)
{
@ -208,7 +208,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator-=(mat<2, 4, U, P> const & m)
{
@ -217,7 +217,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator*=(U s)
{
@ -226,7 +226,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<2, 4, T, P> & mat<2, 4, T, P>::operator/=(U s)
{
@ -237,7 +237,7 @@ namespace glm
// -- Increment and decrement operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator++()
{
++this->value[0];
@ -245,7 +245,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P>& mat<2, 4, T, P>::operator--()
{
--this->value[0];
@ -253,7 +253,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P> mat<2, 4, T, P>::operator++(int)
{
mat<2, 4, T, P> Result(*this);
@ -261,7 +261,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P> mat<2, 4, T, P>::operator--(int)
{
mat<2, 4, T, P> Result(*this);
@ -271,13 +271,13 @@ namespace glm
// -- Unary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator+(mat<2, 4, T, P> const & m)
{
return m;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator-(mat<2, 4, T, P> const & m)
{
return mat<2, 4, T, P>(
@ -287,7 +287,7 @@ namespace glm
// -- Binary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator+(mat<2, 4, T, P> const & m, T scalar)
{
return mat<2, 4, T, P>(
@ -295,7 +295,7 @@ namespace glm
m[1] + scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator+(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2)
{
return mat<2, 4, T, P>(
@ -303,7 +303,7 @@ namespace glm
m1[1] + m2[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator-(mat<2, 4, T, P> const & m, T scalar)
{
return mat<2, 4, T, P>(
@ -311,7 +311,7 @@ namespace glm
m[1] - scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator-(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2)
{
return mat<2, 4, T, P>(
@ -319,7 +319,7 @@ namespace glm
m1[1] - m2[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator*(mat<2, 4, T, P> const & m, T scalar)
{
return mat<2, 4, T, P>(
@ -327,7 +327,7 @@ namespace glm
m[1] * scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator*(T scalar, mat<2, 4, T, P> const & m)
{
return mat<2, 4, T, P>(
@ -335,7 +335,7 @@ namespace glm
m[1] * scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<2, 4, T, P>::col_type operator*(mat<2, 4, T, P> const & m, typename mat<2, 4, T, P>::row_type const & v)
{
return typename mat<2, 4, T, P>::col_type(
@ -345,7 +345,7 @@ namespace glm
m[0][3] * v.x + m[1][3] * v.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<2, 4, T, P>::row_type operator*(typename mat<2, 4, T, P>::col_type const & v, mat<2, 4, T, P> const & m)
{
return typename mat<2, 4, T, P>::row_type(
@ -353,7 +353,7 @@ namespace glm
v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator*(mat<2, 4, T, P> const & m1, mat<4, 2, T, P> const & m2)
{
T SrcA00 = m1[0][0];
@ -394,7 +394,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator*(mat<2, 4, T, P> const & m1, mat<2, 2, T, P> const & m2)
{
return mat<2, 4, T, P>(
@ -408,7 +408,7 @@ namespace glm
m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator*(mat<2, 4, T, P> const & m1, mat<3, 2, T, P> const & m2)
{
return mat<3, 4, T, P>(
@ -426,7 +426,7 @@ namespace glm
m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator/(mat<2, 4, T, P> const & m, T scalar)
{
return mat<2, 4, T, P>(
@ -434,7 +434,7 @@ namespace glm
m[1] / scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator/(T scalar, mat<2, 4, T, P> const & m)
{
return mat<2, 4, T, P>(
@ -444,13 +444,13 @@ namespace glm
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator==(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2)
{
return (m1[0] == m2[0]) && (m1[1] == m2[1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator!=(mat<2, 4, T, P> const & m1, mat<2, 4, T, P> const & m2)
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]);

40
glm/detail/type_mat3x2.hpp
View File

@ -12,7 +12,7 @@
namespace glm
{
template<typename T, precision P>
template<typename T, qualifier P>
struct mat<3, 2, T, P>
{
typedef vec<2, T, P> col_type;
@ -37,7 +37,7 @@ namespace glm
GLM_FUNC_DECL mat() GLM_DEFAULT;
GLM_FUNC_DECL mat(mat<3, 2, T, P> const & m) GLM_DEFAULT;
template<precision Q>
template<qualifier Q>
GLM_FUNC_DECL mat(mat<3, 2, T, Q> const & m);
GLM_FUNC_DECL explicit mat(T scalar);
@ -69,7 +69,7 @@ namespace glm
// -- Matrix conversions --
template<typename U, precision Q>
template<typename U, qualifier Q>
GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 2, U, Q> const & m);
GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x);
@ -110,59 +110,59 @@ namespace glm
// -- Unary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 2, T, P> operator+(mat<3, 2, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 2, T, P> operator-(mat<3, 2, T, P> const & m);
// -- Binary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 2, T, P> operator+(mat<3, 2, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 2, T, P> operator+(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 2, T, P> operator-(mat<3, 2, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 2, T, P> operator-(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 2, T, P> operator*(mat<3, 2, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 2, T, P> operator*(T scalar, mat<3, 2, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<3, 2, T, P>::col_type operator*(mat<3, 2, T, P> const & m, typename mat<3, 2, T, P>::row_type const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<3, 2, T, P>::row_type operator*(typename mat<3, 2, T, P>::col_type const & v, mat<3, 2, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 2, T, P> operator*(mat<3, 2, T, P> const & m1, mat<2, 3, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 2, T, P> operator*(mat<3, 2, T, P> const & m1, mat<3, 3, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 2, T, P> operator*(mat<3, 2, T, P> const & m1, mat<4, 3, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 2, T, P> operator/(mat<3, 2, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 2, T, P> operator/(T scalar, mat<3, 2, T, P> const & m);
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator==(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator!=(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2);
}//namespace glm

100
glm/detail/type_mat3x2.inl
View File

@ -6,13 +6,13 @@ namespace glm
// -- Constructors --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat()
{}
# endif
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<3, 2, T, P> const & m)
{
this->value[0] = m.value[0];
@ -21,8 +21,8 @@ namespace glm
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<precision Q>
template<typename T, qualifier P>
template<qualifier Q>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<3, 2, T, Q> const & m)
{
this->value[0] = m.value[0];
@ -30,7 +30,7 @@ namespace glm
this->value[2] = m.value[2];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(T scalar)
{
this->value[0] = col_type(scalar, 0);
@ -38,7 +38,7 @@ namespace glm
this->value[2] = col_type(0, 0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat
(
T x0, T y0,
@ -51,7 +51,7 @@ namespace glm
this->value[2] = col_type(x2, y2);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat
(
col_type const & v0,
@ -66,7 +66,7 @@ namespace glm
// -- Conversion constructors --
template<typename T, precision P>
template<typename T, qualifier P>
template<
typename X1, typename Y1,
typename X2, typename Y2,
@ -83,7 +83,7 @@ namespace glm
this->value[2] = col_type(static_cast<T>(x3), value_type(y3));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename V1, typename V2, typename V3>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat
(
@ -99,8 +99,8 @@ namespace glm
// -- Matrix conversions --
template<typename T, precision P>
template<typename U, precision Q>
template<typename T, qualifier P>
template<typename U, qualifier Q>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<3, 2, U, Q> const & m)
{
this->value[0] = col_type(m[0]);
@ -108,7 +108,7 @@ namespace glm
this->value[2] = col_type(m[2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<2, 2, T, P> const & m)
{
this->value[0] = m[0];
@ -116,7 +116,7 @@ namespace glm
this->value[2] = col_type(0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<3, 3, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -124,7 +124,7 @@ namespace glm
this->value[2] = col_type(m[2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<4, 4, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -132,7 +132,7 @@ namespace glm
this->value[2] = col_type(m[2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<2, 3, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -140,7 +140,7 @@ namespace glm
this->value[2] = col_type(T(0));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<2, 4, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -148,7 +148,7 @@ namespace glm
this->value[2] = col_type(T(0));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<3, 4, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -156,7 +156,7 @@ namespace glm
this->value[2] = col_type(m[2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<4, 2, T, P> const & m)
{
this->value[0] = m[0];
@ -164,7 +164,7 @@ namespace glm
this->value[2] = m[2];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>::mat(mat<4, 3, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -174,14 +174,14 @@ namespace glm
// -- Accesses --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<3, 2, T, P>::col_type & mat<3, 2, T, P>::operator[](typename mat<3, 2, T, P>::length_type i)
{
assert(i < this->length());
return this->value[i];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<3, 2, T, P>::col_type const & mat<3, 2, T, P>::operator[](typename mat<3, 2, T, P>::length_type i) const
{
assert(i < this->length());
@ -191,7 +191,7 @@ namespace glm
// -- Unary updatable operators --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator=(mat<3, 2, T, P> const & m)
{
this->value[0] = m[0];
@ -201,7 +201,7 @@ namespace glm
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator=(mat<3, 2, U, P> const & m)
{
@ -211,7 +211,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator+=(U s)
{
@ -221,7 +221,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator+=(mat<3, 2, U, P> const & m)
{
@ -231,7 +231,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator-=(U s)
{
@ -241,7 +241,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator-=(mat<3, 2, U, P> const & m)
{
@ -251,7 +251,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator*=(U s)
{
@ -261,7 +261,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 2, T, P> & mat<3, 2, T, P>::operator/=(U s)
{
@ -273,7 +273,7 @@ namespace glm
// -- Increment and decrement operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator++()
{
++this->value[0];
@ -282,7 +282,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P>& mat<3, 2, T, P>::operator--()
{
--this->value[0];
@ -291,7 +291,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P> mat<3, 2, T, P>::operator++(int)
{
mat<3, 2, T, P> Result(*this);
@ -299,7 +299,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P> mat<3, 2, T, P>::operator--(int)
{
mat<3, 2, T, P> Result(*this);
@ -309,13 +309,13 @@ namespace glm
// -- Unary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator+(mat<3, 2, T, P> const & m)
{
return m;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator-(mat<3, 2, T, P> const & m)
{
return mat<3, 2, T, P>(
@ -326,7 +326,7 @@ namespace glm
// -- Binary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator+(mat<3, 2, T, P> const & m, T scalar)
{
return mat<3, 2, T, P>(
@ -335,7 +335,7 @@ namespace glm
m[2] + scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator+(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2)
{
return mat<3, 2, T, P>(
@ -344,7 +344,7 @@ namespace glm
m1[2] + m2[2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator-(mat<3, 2, T, P> const & m, T scalar)
{
return mat<3, 2, T, P>(
@ -353,7 +353,7 @@ namespace glm
m[2] - scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator-(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2)
{
return mat<3, 2, T, P>(
@ -362,7 +362,7 @@ namespace glm
m1[2] - m2[2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator*(mat<3, 2, T, P> const & m, T scalar)
{
return mat<3, 2, T, P>(
@ -371,7 +371,7 @@ namespace glm
m[2] * scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator*(T scalar, mat<3, 2, T, P> const & m)
{
return mat<3, 2, T, P>(
@ -380,7 +380,7 @@ namespace glm
m[2] * scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<3, 2, T, P>::col_type operator*(mat<3, 2, T, P> const & m, typename mat<3, 2, T, P>::row_type const & v)
{
return typename mat<3, 2, T, P>::col_type(
@ -388,7 +388,7 @@ namespace glm
m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<3, 2, T, P>::row_type operator*(typename mat<3, 2, T, P>::col_type const & v, mat<3, 2, T, P> const & m)
{
return typename mat<3, 2, T, P>::row_type(
@ -397,7 +397,7 @@ namespace glm
v.x * m[2][0] + v.y * m[2][1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator*(mat<3, 2, T, P> const & m1, mat<2, 3, T, P> const & m2)
{
const T SrcA00 = m1[0][0];
@ -422,7 +422,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator*(mat<3, 2, T, P> const & m1, mat<3, 3, T, P> const & m2)
{
return mat<3, 2, T, P>(
@ -434,7 +434,7 @@ namespace glm
m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator*(mat<3, 2, T, P> const & m1, mat<4, 3, T, P> const & m2)
{
return mat<4, 2, T, P>(
@ -448,7 +448,7 @@ namespace glm
m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator/(mat<3, 2, T, P> const & m, T scalar)
{
return mat<3, 2, T, P>(
@ -457,7 +457,7 @@ namespace glm
m[2] / scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator/(T scalar, mat<3, 2, T, P> const & m)
{
return mat<3, 2, T, P>(
@ -468,13 +468,13 @@ namespace glm
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator==(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2)
{
return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator!=(mat<3, 2, T, P> const & m1, mat<3, 2, T, P> const & m2)
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);

50
glm/detail/type_mat3x3.hpp
View File

@ -11,7 +11,7 @@
namespace glm
{
template<typename T, precision P>
template<typename T, qualifier P>
struct mat<3, 3, T, P>
{
typedef vec<3, T, P> col_type;
@ -36,7 +36,7 @@ namespace glm
GLM_FUNC_DECL mat() GLM_DEFAULT;
GLM_FUNC_DECL mat(mat<3, 3, T, P> const & m) GLM_DEFAULT;
template<precision Q>
template<qualifier Q>
GLM_FUNC_DECL mat(mat<3, 3, T, Q> const & m);
GLM_FUNC_DECL explicit mat(T scalar);
@ -68,7 +68,7 @@ namespace glm
// -- Matrix conversions --
template<typename U, precision Q>
template<typename U, qualifier Q>
GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 3, U, Q> const & m);
GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x);
@ -113,74 +113,74 @@ namespace glm
// -- Unary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 3, T, P> operator+(mat<3, 3, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 3, T, P> operator-(mat<3, 3, T, P> const & m);
// -- Binary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 3, T, P> operator+(mat<3, 3, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 3, T, P> operator+(T scalar, mat<3, 3, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 3, T, P> operator+(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 3, T, P> operator-(mat<3, 3, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 3, T, P> operator-(T scalar, mat<3, 3, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 3, T, P> operator-(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 3, T, P> operator*(mat<3, 3, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 3, T, P> operator*(T scalar, mat<3, 3, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<3, 3, T, P>::col_type operator*(mat<3, 3, T, P> const & m, typename mat<3, 3, T, P>::row_type const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<3, 3, T, P>::row_type operator*(typename mat<3, 3, T, P>::col_type const & v, mat<3, 3, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 3, T, P> operator*(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 3, T, P> operator*(mat<3, 3, T, P> const & m1, mat<2, 3, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 3, T, P> operator*(mat<3, 3, T, P> const & m1, mat<4, 3, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 3, T, P> operator/(mat<3, 3, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 3, T, P> operator/(T scalar, mat<3, 3, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<3, 3, T, P>::col_type operator/(mat<3, 3, T, P> const & m, typename mat<3, 3, T, P>::row_type const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<3, 3, T, P>::row_type operator/(typename mat<3, 3, T, P>::col_type const & v, mat<3, 3, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 3, T, P> operator/(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2);
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator==(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator!=(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2);
}//namespace glm

114
glm/detail/type_mat3x3.inl
View File

@ -8,13 +8,13 @@ namespace glm
// -- Constructors --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat()
{}
# endif
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<3, 3, T, P> const & m)
{
this->value[0] = m.value[0];
@ -23,8 +23,8 @@ namespace glm
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<precision Q>
template<typename T, qualifier P>
template<qualifier Q>
GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<3, 3, T, Q> const & m)
{
this->value[0] = m.value[0];
@ -32,7 +32,7 @@ namespace glm
this->value[2] = m.value[2];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(T scalar)
{
this->value[0] = col_type(scalar, 0, 0);
@ -40,7 +40,7 @@ namespace glm
this->value[2] = col_type(0, 0, scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat
(
T x0, T y0, T z0,
@ -53,7 +53,7 @@ namespace glm
this->value[2] = col_type(x2, y2, z2);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat
(
col_type const & v0,
@ -68,7 +68,7 @@ namespace glm
// -- Conversion constructors --
template<typename T, precision P>
template<typename T, qualifier P>
template<
typename X1, typename Y1, typename Z1,
typename X2, typename Y2, typename Z2,
@ -85,7 +85,7 @@ namespace glm
this->value[2] = col_type(static_cast<T>(x3), value_type(y3), value_type(z3));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename V1, typename V2, typename V3>
GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat
(
@ -101,8 +101,8 @@ namespace glm
// -- Matrix conversions --
template<typename T, precision P>
template<typename U, precision Q>
template<typename T, qualifier P>
template<typename U, qualifier Q>
GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<3, 3, U, Q> const & m)
{
this->value[0] = col_type(m[0]);
@ -110,7 +110,7 @@ namespace glm
this->value[2] = col_type(m[2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<2, 2, T, P> const & m)
{
this->value[0] = col_type(m[0], 0);
@ -118,7 +118,7 @@ namespace glm
this->value[2] = col_type(0, 0, 1);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<4, 4, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -126,7 +126,7 @@ namespace glm
this->value[2] = col_type(m[2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<2, 3, T, P> const & m)
{
this->value[0] = m[0];
@ -134,7 +134,7 @@ namespace glm
this->value[2] = col_type(0, 0, 1);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<3, 2, T, P> const & m)
{
this->value[0] = col_type(m[0], 0);
@ -142,7 +142,7 @@ namespace glm
this->value[2] = col_type(m[2], 1);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<2, 4, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -150,7 +150,7 @@ namespace glm
this->value[2] = col_type(0, 0, 1);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<4, 2, T, P> const & m)
{
this->value[0] = col_type(m[0], 0);
@ -158,7 +158,7 @@ namespace glm
this->value[2] = col_type(m[2], 1);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<3, 4, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -166,7 +166,7 @@ namespace glm
this->value[2] = col_type(m[2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P>::mat(mat<4, 3, T, P> const & m)
{
this->value[0] = m[0];
@ -176,14 +176,14 @@ namespace glm
// -- Accesses --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<3, 3, T, P>::col_type & mat<3, 3, T, P>::operator[](typename mat<3, 3, T, P>::length_type i)
{
assert(i < this->length());
return this->value[i];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<3, 3, T, P>::col_type const & mat<3, 3, T, P>::operator[](typename mat<3, 3, T, P>::length_type i) const
{
assert(i < this->length());
@ -193,7 +193,7 @@ namespace glm
// -- Unary updatable operators --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator=(mat<3, 3, T, P> const & m)
{
this->value[0] = m[0];
@ -203,7 +203,7 @@ namespace glm
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator=(mat<3, 3, U, P> const & m)
{
@ -213,7 +213,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator+=(U s)
{
@ -223,7 +223,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator+=(mat<3, 3, U, P> const & m)
{
@ -233,7 +233,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator-=(U s)
{
@ -243,7 +243,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator-=(mat<3, 3, U, P> const & m)
{
@ -253,7 +253,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator*=(U s)
{
@ -263,14 +263,14 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator*=(mat<3, 3, U, P> const & m)
{
return (*this = *this * m);
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator/=(U s)
{
@ -280,7 +280,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator/=(mat<3, 3, U, P> const & m)
{
@ -289,7 +289,7 @@ namespace glm
// -- Increment and decrement operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator++()
{
++this->value[0];
@ -298,7 +298,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> & mat<3, 3, T, P>::operator--()
{
--this->value[0];
@ -307,7 +307,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> mat<3, 3, T, P>::operator++(int)
{
mat<3, 3, T, P> Result(*this);
@ -315,7 +315,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> mat<3, 3, T, P>::operator--(int)
{
mat<3, 3, T, P> Result(*this);
@ -325,13 +325,13 @@ namespace glm
// -- Unary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator+(mat<3, 3, T, P> const & m)
{
return m;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator-(mat<3, 3, T, P> const & m)
{
return mat<3, 3, T, P>(
@ -342,7 +342,7 @@ namespace glm
// -- Binary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator+(mat<3, 3, T, P> const & m, T scalar)
{
return mat<3, 3, T, P>(
@ -351,7 +351,7 @@ namespace glm
m[2] + scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator+(T scalar, mat<3, 3, T, P> const & m)
{
return mat<3, 3, T, P>(
@ -360,7 +360,7 @@ namespace glm
m[2] + scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator+(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2)
{
return mat<3, 3, T, P>(
@ -369,7 +369,7 @@ namespace glm
m1[2] + m2[2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator-(mat<3, 3, T, P> const & m, T scalar)
{
return mat<3, 3, T, P>(
@ -378,7 +378,7 @@ namespace glm
m[2] - scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator-(T scalar, mat<3, 3, T, P> const & m)
{
return mat<3, 3, T, P>(
@ -387,7 +387,7 @@ namespace glm
scalar - m[2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator-(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2)
{
return mat<3, 3, T, P>(
@ -396,7 +396,7 @@ namespace glm
m1[2] - m2[2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator*(mat<3, 3, T, P> const & m, T scalar)
{
return mat<3, 3, T, P>(
@ -405,7 +405,7 @@ namespace glm
m[2] * scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator*(T scalar, mat<3, 3, T, P> const & m)
{
return mat<3, 3, T, P>(
@ -414,7 +414,7 @@ namespace glm
m[2] * scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<3, 3, T, P>::col_type operator*(mat<3, 3, T, P> const & m, typename mat<3, 3, T, P>::row_type const & v)
{
return typename mat<3, 3, T, P>::col_type(
@ -423,7 +423,7 @@ namespace glm
m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<3, 3, T, P>::row_type operator*(typename mat<3, 3, T, P>::col_type const & v, mat<3, 3, T, P> const & m)
{
return typename mat<3, 3, T, P>::row_type(
@ -432,7 +432,7 @@ namespace glm
m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator*(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2)
{
T const SrcA00 = m1[0][0];
@ -468,7 +468,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator*(mat<3, 3, T, P> const & m1, mat<2, 3, T, P> const & m2)
{
return mat<2, 3, T, P>(
@ -480,7 +480,7 @@ namespace glm
m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator*(mat<3, 3, T, P> const & m1, mat<4, 3, T, P> const & m2)
{
return mat<4, 3, T, P>(
@ -498,7 +498,7 @@ namespace glm
m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator/(mat<3, 3, T, P> const & m, T scalar)
{
return mat<3, 3, T, P>(
@ -507,7 +507,7 @@ namespace glm
m[2] / scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator/(T scalar, mat<3, 3, T, P> const & m)
{
return mat<3, 3, T, P>(
@ -516,19 +516,19 @@ namespace glm
scalar / m[2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<3, 3, T, P>::col_type operator/(mat<3, 3, T, P> const & m, typename mat<3, 3, T, P>::row_type const & v)
{
return inverse(m) * v;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<3, 3, T, P>::row_type operator/(typename mat<3, 3, T, P>::col_type const & v, mat<3, 3, T, P> const & m)
{
return v * inverse(m);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator/(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2)
{
mat<3, 3, T, P> m1_copy(m1);
@ -537,13 +537,13 @@ namespace glm
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator==(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2)
{
return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator!=(mat<3, 3, T, P> const & m1, mat<3, 3, T, P> const & m2)
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);

40
glm/detail/type_mat3x4.hpp
View File

@ -12,7 +12,7 @@
namespace glm
{
template<typename T, precision P>
template<typename T, qualifier P>
struct mat<3, 4, T, P>
{
typedef vec<4, T, P> col_type;
@ -37,7 +37,7 @@ namespace glm
GLM_FUNC_DECL mat() GLM_DEFAULT;
GLM_FUNC_DECL mat(mat<3, 4, T, P> const & m) GLM_DEFAULT;
template<precision Q>
template<qualifier Q>
GLM_FUNC_DECL mat(mat<3, 4, T, Q> const & m);
GLM_FUNC_DECL explicit mat(T scalar);
@ -69,7 +69,7 @@ namespace glm
// -- Matrix conversions --
template<typename U, precision Q>
template<typename U, qualifier Q>
GLM_FUNC_DECL GLM_EXPLICIT mat(mat<3, 4, U, Q> const & m);
GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x);
@ -110,59 +110,59 @@ namespace glm
// -- Unary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 4, T, P> operator+(mat<3, 4, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 4, T, P> operator-(mat<3, 4, T, P> const & m);
// -- Binary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 4, T, P> operator+(mat<3, 4, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 4, T, P> operator+(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 4, T, P> operator-(mat<3, 4, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 4, T, P> operator-(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 4, T, P> operator*(mat<3, 4, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 4, T, P> operator*(T scalar, mat<3, 4, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<3, 4, T, P>::col_type operator*(mat<3, 4, T, P> const & m, typename mat<3, 4, T, P>::row_type const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<3, 4, T, P>::row_type operator*(typename mat<3, 4, T, P>::col_type const & v, mat<3, 4, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> operator*(mat<3, 4, T, P> const & m1, mat<4, 3, T, P> const& m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 4, T, P> operator*(mat<3, 4, T, P> const & m1, mat<2, 3, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 4, T, P> operator*(mat<3, 4, T, P> const & m1, mat<3, 3, T, P> const& m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 4, T, P> operator/(mat<3, 4, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 4, T, P> operator/(T scalar, mat<3, 4, T, P> const & m);
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator==(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator!=(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2);
}//namespace glm

100
glm/detail/type_mat3x4.inl
View File

@ -6,13 +6,13 @@ namespace glm
// -- Constructors --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat()
{}
# endif
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<3, 4, T, P> const & m)
{
this->value[0] = m.value[0];
@ -21,8 +21,8 @@ namespace glm
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<precision Q>
template<typename T, qualifier P>
template<qualifier Q>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<3, 4, T, Q> const & m)
{
this->value[0] = m.value[0];
@ -30,7 +30,7 @@ namespace glm
this->value[2] = m.value[2];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(T scalar)
{
this->value[0] = col_type(scalar, 0, 0, 0);
@ -38,7 +38,7 @@ namespace glm
this->value[2] = col_type(0, 0, scalar, 0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat
(
T x0, T y0, T z0, T w0,
@ -51,7 +51,7 @@ namespace glm
this->value[2] = col_type(x2, y2, z2, w2);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat
(
col_type const & v0,
@ -66,7 +66,7 @@ namespace glm
// -- Conversion constructors --
template<typename T, precision P>
template<typename T, qualifier P>
template<
typename X1, typename Y1, typename Z1, typename W1,
typename X2, typename Y2, typename Z2, typename W2,
@ -83,7 +83,7 @@ namespace glm
this->value[2] = col_type(static_cast<T>(x3), value_type(y3), value_type(z3), value_type(w3));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename V1, typename V2, typename V3>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat
(
@ -99,8 +99,8 @@ namespace glm
// -- Matrix conversions --
template<typename T, precision P>
template<typename U, precision Q>
template<typename T, qualifier P>
template<typename U, qualifier Q>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<3, 4, U, Q> const & m)
{
this->value[0] = col_type(m[0]);
@ -108,7 +108,7 @@ namespace glm
this->value[2] = col_type(m[2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<2, 2, T, P> const & m)
{
this->value[0] = col_type(m[0], 0, 0);
@ -116,7 +116,7 @@ namespace glm
this->value[2] = col_type(0, 0, 1, 0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<3, 3, T, P> const & m)
{
this->value[0] = col_type(m[0], 0);
@ -124,7 +124,7 @@ namespace glm
this->value[2] = col_type(m[2], 0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<4, 4, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -132,7 +132,7 @@ namespace glm
this->value[2] = col_type(m[2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<2, 3, T, P> const & m)
{
this->value[0] = col_type(m[0], 0);
@ -140,7 +140,7 @@ namespace glm
this->value[2] = col_type(0, 0, 1, 0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<3, 2, T, P> const & m)
{
this->value[0] = col_type(m[0], 0, 0);
@ -148,7 +148,7 @@ namespace glm
this->value[2] = col_type(m[2], 1, 0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<2, 4, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -156,7 +156,7 @@ namespace glm
this->value[2] = col_type(0, 0, 1, 0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<4, 2, T, P> const & m)
{
this->value[0] = col_type(m[0], 0, 0);
@ -164,7 +164,7 @@ namespace glm
this->value[2] = col_type(m[2], 1, 0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>::mat(mat<4, 3, T, P> const & m)
{
this->value[0] = col_type(m[0], 0);
@ -174,14 +174,14 @@ namespace glm
// -- Accesses --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<3, 4, T, P>::col_type & mat<3, 4, T, P>::operator[](typename mat<3, 4, T, P>::length_type i)
{
assert(i < this->length());
return this->value[i];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<3, 4, T, P>::col_type const & mat<3, 4, T, P>::operator[](typename mat<3, 4, T, P>::length_type i) const
{
assert(i < this->length());
@ -191,7 +191,7 @@ namespace glm
// -- Unary updatable operators --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator=(mat<3, 4, T, P> const & m)
{
this->value[0] = m[0];
@ -201,7 +201,7 @@ namespace glm
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator=(mat<3, 4, U, P> const & m)
{
@ -211,7 +211,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator+=(U s)
{
@ -221,7 +221,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator+=(mat<3, 4, U, P> const & m)
{
@ -231,7 +231,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator-=(U s)
{
@ -241,7 +241,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator-=(mat<3, 4, U, P> const & m)
{
@ -251,7 +251,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator*=(U s)
{
@ -261,7 +261,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<3, 4, T, P> & mat<3, 4, T, P>::operator/=(U s)
{
@ -273,7 +273,7 @@ namespace glm
// -- Increment and decrement operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator++()
{
++this->value[0];
@ -282,7 +282,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P>& mat<3, 4, T, P>::operator--()
{
--this->value[0];
@ -291,7 +291,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P> mat<3, 4, T, P>::operator++(int)
{
mat<3, 4, T, P> Result(*this);
@ -299,7 +299,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P> mat<3, 4, T, P>::operator--(int)
{
mat<3, 4, T, P> Result(*this);
@ -309,13 +309,13 @@ namespace glm
// -- Unary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator+(mat<3, 4, T, P> const & m)
{
return m;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator-(mat<3, 4, T, P> const & m)
{
return mat<3, 4, T, P>(
@ -326,7 +326,7 @@ namespace glm
// -- Binary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator+(mat<3, 4, T, P> const & m, T scalar)
{
return mat<3, 4, T, P>(
@ -335,7 +335,7 @@ namespace glm
m[2] + scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator+(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2)
{
return mat<3, 4, T, P>(
@ -344,7 +344,7 @@ namespace glm
m1[2] + m2[2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator-(mat<3, 4, T, P> const & m, T scalar)
{
return mat<3, 4, T, P>(
@ -353,7 +353,7 @@ namespace glm
m[2] - scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator-(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2)
{
return mat<3, 4, T, P>(
@ -362,7 +362,7 @@ namespace glm
m1[2] - m2[2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator*(mat<3, 4, T, P> const & m, T scalar)
{
return mat<3, 4, T, P>(
@ -371,7 +371,7 @@ namespace glm
m[2] * scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator*(T scalar, mat<3, 4, T, P> const & m)
{
return mat<3, 4, T, P>(
@ -380,7 +380,7 @@ namespace glm
m[2] * scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<3, 4, T, P>::col_type operator*
(
mat<3, 4, T, P> const& m,
@ -394,7 +394,7 @@ namespace glm
m[0][3] * v.x + m[1][3] * v.y + m[2][3] * v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<3, 4, T, P>::row_type operator*
(
typename mat<3, 4, T, P>::col_type const & v,
@ -407,7 +407,7 @@ namespace glm
v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2] + v.w * m[2][3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator*(mat<3, 4, T, P> const & m1, mat<4, 3, T, P> const & m2)
{
const T SrcA00 = m1[0][0];
@ -456,7 +456,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator*(mat<3, 4, T, P> const & m1, mat<2, 3, T, P> const & m2)
{
return mat<2, 4, T, P>(
@ -470,7 +470,7 @@ namespace glm
m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator*(mat<3, 4, T, P> const & m1, mat<3, 3, T, P> const & m2)
{
return mat<3, 4, T, P>(
@ -488,7 +488,7 @@ namespace glm
m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator/(mat<3, 4, T, P> const & m, T scalar)
{
return mat<3, 4, T, P>(
@ -497,7 +497,7 @@ namespace glm
m[2] / scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator/(T scalar, mat<3, 4, T, P> const & m)
{
return mat<3, 4, T, P>(
@ -508,13 +508,13 @@ namespace glm
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator==(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2)
{
return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator!=(mat<3, 4, T, P> const & m1, mat<3, 4, T, P> const & m2)
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);

40
glm/detail/type_mat4x2.hpp
View File

@ -12,7 +12,7 @@
namespace glm
{
template<typename T, precision P>
template<typename T, qualifier P>
struct mat<4, 2, T, P>
{
typedef vec<2, T, P> col_type;
@ -37,7 +37,7 @@ namespace glm
GLM_FUNC_DECL mat() GLM_DEFAULT;
GLM_FUNC_DECL mat(mat<4, 2, T, P> const & m) GLM_DEFAULT;
template<precision Q>
template<qualifier Q>
GLM_FUNC_DECL mat(mat<4, 2, T, Q> const & m);
GLM_FUNC_DECL explicit mat(T scalar);
@ -74,7 +74,7 @@ namespace glm
// -- Matrix conversions --
template<typename U, precision Q>
template<typename U, qualifier Q>
GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 2, U, Q> const & m);
GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x);
@ -115,59 +115,59 @@ namespace glm
// -- Unary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 2, T, P> operator+(mat<4, 2, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 2, T, P> operator-(mat<4, 2, T, P> const & m);
// -- Binary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 2, T, P> operator+(mat<4, 2, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 2, T, P> operator+(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 2, T, P> operator-(mat<4, 2, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 2, T, P> operator-(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const& m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 2, T, P> operator*(mat<4, 2, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 2, T, P> operator*(T scalar, mat<4, 2, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<4, 2, T, P>::col_type operator*(mat<4, 2, T, P> const & m, typename mat<4, 2, T, P>::row_type const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<4, 2, T, P>::row_type operator*(typename mat<4, 2, T, P>::col_type const & v, mat<4, 2, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 2, T, P> operator*(mat<4, 2, T, P> const & m1, mat<2, 4, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 2, T, P> operator*(mat<4, 2, T, P> const & m1, mat<3, 4, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 2, T, P> operator*(mat<4, 2, T, P> const & m1, mat<4, 4, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 2, T, P> operator/(mat<4, 2, T, P> const & m, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 2, T, P> operator/(T scalar, mat<4, 2, T, P> const & m);
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator==(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator!=(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const & m2);
}//namespace glm

100
glm/detail/type_mat4x2.inl
View File

@ -6,13 +6,13 @@ namespace glm
// -- Constructors --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat()
{}
# endif
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<4, 2, T, P> const & m)
{
this->value[0] = m.value[0];
@ -22,8 +22,8 @@ namespace glm
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<precision Q>
template<typename T, qualifier P>
template<qualifier Q>
GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<4, 2, T, Q> const & m)
{
this->value[0] = m.value[0];
@ -32,7 +32,7 @@ namespace glm
this->value[3] = m.value[3];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(T scalar)
{
this->value[0] = col_type(scalar, 0);
@ -41,7 +41,7 @@ namespace glm
this->value[3] = col_type(0, 0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat
(
T x0, T y0,
@ -56,7 +56,7 @@ namespace glm
this->value[3] = col_type(x3, y3);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat
(
col_type const & v0,
@ -73,7 +73,7 @@ namespace glm
// -- Conversion constructors --
template<typename T, precision P>
template<typename T, qualifier P>
template<
typename X1, typename Y1,
typename X2, typename Y2,
@ -93,7 +93,7 @@ namespace glm
this->value[3] = col_type(static_cast<T>(x4), value_type(y4));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename V1, typename V2, typename V3, typename V4>
GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat
(
@ -111,8 +111,8 @@ namespace glm
// -- Conversion --
template<typename T, precision P>
template<typename U, precision Q>
template<typename T, qualifier P>
template<typename U, qualifier Q>
GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<4, 2, U, Q> const & m)
{
this->value[0] = col_type(m[0]);
@ -121,7 +121,7 @@ namespace glm
this->value[3] = col_type(m[3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<2, 2, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -130,7 +130,7 @@ namespace glm
this->value[3] = col_type(0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<3, 3, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -139,7 +139,7 @@ namespace glm
this->value[3] = col_type(0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<4, 4, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -148,7 +148,7 @@ namespace glm
this->value[3] = col_type(m[3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<2, 3, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -157,7 +157,7 @@ namespace glm
this->value[3] = col_type(0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<3, 2, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -166,7 +166,7 @@ namespace glm
this->value[3] = col_type(0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<2, 4, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -175,7 +175,7 @@ namespace glm
this->value[3] = col_type(0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<4, 3, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -184,7 +184,7 @@ namespace glm
this->value[3] = col_type(m[3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P>::mat(mat<3, 4, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -195,14 +195,14 @@ namespace glm
// -- Accesses --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<4, 2, T, P>::col_type & mat<4, 2, T, P>::operator[](typename mat<4, 2, T, P>::length_type i)
{
assert(i < this->length());
return this->value[i];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<4, 2, T, P>::col_type const & mat<4, 2, T, P>::operator[](typename mat<4, 2, T, P>::length_type i) const
{
assert(i < this->length());
@ -212,7 +212,7 @@ namespace glm
// -- Unary updatable operators --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P>& mat<4, 2, T, P>::operator=(mat<4, 2, T, P> const & m)
{
this->value[0] = m[0];
@ -223,7 +223,7 @@ namespace glm
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 2, T, P>& mat<4, 2, T, P>::operator=(mat<4, 2, U, P> const & m)
{
@ -234,7 +234,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator+=(U s)
{
@ -245,7 +245,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator+=(mat<4, 2, U, P> const & m)
{
@ -256,7 +256,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator-=(U s)
{
@ -267,7 +267,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator-=(mat<4, 2, U, P> const & m)
{
@ -278,7 +278,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator*=(U s)
{
@ -289,7 +289,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator/=(U s)
{
@ -302,7 +302,7 @@ namespace glm
// -- Increment and decrement operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator++()
{
++this->value[0];
@ -312,7 +312,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> & mat<4, 2, T, P>::operator--()
{
--this->value[0];
@ -322,7 +322,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> mat<4, 2, T, P>::operator++(int)
{
mat<4, 2, T, P> Result(*this);
@ -330,7 +330,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> mat<4, 2, T, P>::operator--(int)
{
mat<4, 2, T, P> Result(*this);
@ -340,13 +340,13 @@ namespace glm
// -- Unary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator+(mat<4, 2, T, P> const & m)
{
return m;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator-(mat<4, 2, T, P> const & m)
{
return mat<4, 2, T, P>(
@ -358,7 +358,7 @@ namespace glm
// -- Binary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator+(mat<4, 2, T, P> const & m, T scalar)
{
return mat<4, 2, T, P>(
@ -368,7 +368,7 @@ namespace glm
m[3] + scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator+(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const & m2)
{
return mat<4, 2, T, P>(
@ -378,7 +378,7 @@ namespace glm
m1[3] + m2[3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator-(mat<4, 2, T, P> const & m, T scalar)
{
return mat<4, 2, T, P>(
@ -388,7 +388,7 @@ namespace glm
m[3] - scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator-(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const & m2)
{
return mat<4, 2, T, P>(
@ -398,7 +398,7 @@ namespace glm
m1[3] - m2[3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator*(mat<4, 2, T, P> const & m, T scalar)
{
return mat<4, 2, T, P>(
@ -408,7 +408,7 @@ namespace glm
m[3] * scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator*(T scalar, mat<4, 2, T, P> const & m)
{
return mat<4, 2, T, P>(
@ -418,7 +418,7 @@ namespace glm
m[3] * scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<4, 2, T, P>::col_type operator*(mat<4, 2, T, P> const & m, typename mat<4, 2, T, P>::row_type const & v)
{
return typename mat<4, 2, T, P>::col_type(
@ -426,7 +426,7 @@ namespace glm
m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<4, 2, T, P>::row_type operator*(typename mat<4, 2, T, P>::col_type const & v, mat<4, 2, T, P> const & m)
{
return typename mat<4, 2, T, P>::row_type(
@ -436,7 +436,7 @@ namespace glm
v.x * m[3][0] + v.y * m[3][1]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P> operator*(mat<4, 2, T, P> const & m1, mat<2, 4, T, P> const & m2)
{
T const SrcA00 = m1[0][0];
@ -465,7 +465,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 2, T, P> operator*(mat<4, 2, T, P> const & m1, mat<3, 4, T, P> const & m2)
{
return mat<3, 2, T, P>(
@ -477,7 +477,7 @@ namespace glm
m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator*(mat<4, 2, T, P> const & m1, mat<4, 4, T, P> const & m2)
{
return mat<4, 2, T, P>(
@ -491,7 +491,7 @@ namespace glm
m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2] + m1[3][1] * m2[3][3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator/(mat<4, 2, T, P> const & m, T scalar)
{
return mat<4, 2, T, P>(
@ -501,7 +501,7 @@ namespace glm
m[3] / scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 2, T, P> operator/(T scalar, mat<4, 2, T, P> const & m)
{
return mat<4, 2, T, P>(
@ -513,13 +513,13 @@ namespace glm
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator==(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const & m2)
{
return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator!=(mat<4, 2, T, P> const & m1, mat<4, 2, T, P> const & m2)
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);

40
glm/detail/type_mat4x3.hpp
View File

@ -12,7 +12,7 @@
namespace glm
{
template<typename T, precision P>
template<typename T, qualifier P>
struct mat<4, 3, T, P>
{
typedef vec<3, T, P> col_type;
@ -37,7 +37,7 @@ namespace glm
GLM_FUNC_DECL mat() GLM_DEFAULT;
GLM_FUNC_DECL mat(mat<4, 3, T, P> const & m) GLM_DEFAULT;
template<precision Q>
template<qualifier Q>
GLM_FUNC_DECL mat(mat<4, 3, T, Q> const & m);
GLM_FUNC_DECL explicit mat(T const & x);
@ -74,7 +74,7 @@ namespace glm
// -- Matrix conversions --
template<typename U, precision Q>
template<typename U, qualifier Q>
GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 3, U, Q> const & m);
GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x);
@ -115,59 +115,59 @@ namespace glm
// -- Unary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 3, T, P> operator+(mat<4, 3, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 3, T, P> operator-(mat<4, 3, T, P> const & m);
// -- Binary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 3, T, P> operator+(mat<4, 3, T, P> const & m, T const & s);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 3, T, P> operator+(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 3, T, P> operator-(mat<4, 3, T, P> const & m, T const & s);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 3, T, P> operator-(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 3, T, P> operator*(mat<4, 3, T, P> const & m, T const & s);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 3, T, P> operator*(T const & s, mat<4, 3, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<4, 3, T, P>::col_type operator*(mat<4, 3, T, P> const & m, typename mat<4, 3, T, P>::row_type const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<4, 3, T, P>::row_type operator*(typename mat<4, 3, T, P>::col_type const & v, mat<4, 3, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 3, T, P> operator*(mat<4, 3, T, P> const & m1, mat<2, 4, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 3, T, P> operator*(mat<4, 3, T, P> const & m1, mat<3, 4, T, P> const& m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 3, T, P> operator*(mat<4, 3, T, P> const & m1, mat<4, 4, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 3, T, P> operator/(mat<4, 3, T, P> const & m, T const & s);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 3, T, P> operator/(T const & s, mat<4, 3, T, P> const & m);
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator==(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator!=(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2);
}//namespace glm

100
glm/detail/type_mat4x3.inl
View File

@ -6,13 +6,13 @@ namespace glm
// -- Constructors --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat()
{}
# endif
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<4, 3, T, P> const & m)
{
this->value[0] = m.value[0];
@ -22,8 +22,8 @@ namespace glm
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<precision Q>
template<typename T, qualifier P>
template<qualifier Q>
GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<4, 3, T, Q> const & m)
{
this->value[0] = m.value[0];
@ -32,7 +32,7 @@ namespace glm
this->value[3] = m.value[3];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(T const & s)
{
this->value[0] = col_type(s, 0, 0);
@ -41,7 +41,7 @@ namespace glm
this->value[3] = col_type(0, 0, 0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat
(
T const & x0, T const & y0, T const & z0,
@ -56,7 +56,7 @@ namespace glm
this->value[3] = col_type(x3, y3, z3);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat
(
col_type const & v0,
@ -73,7 +73,7 @@ namespace glm
// -- Conversion constructors --
template<typename T, precision P>
template<typename T, qualifier P>
template<
typename X1, typename Y1, typename Z1,
typename X2, typename Y2, typename Z2,
@ -93,7 +93,7 @@ namespace glm
this->value[3] = col_type(static_cast<T>(x4), value_type(y4), value_type(z4));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename V1, typename V2, typename V3, typename V4>
GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat
(
@ -111,8 +111,8 @@ namespace glm
// -- Matrix conversions --
template<typename T, precision P>
template<typename U, precision Q>
template<typename T, qualifier P>
template<typename U, qualifier Q>
GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<4, 3, U, Q> const & m)
{
this->value[0] = col_type(m[0]);
@ -121,7 +121,7 @@ namespace glm
this->value[3] = col_type(m[3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<2, 2, T, P> const & m)
{
this->value[0] = col_type(m[0], 0);
@ -130,7 +130,7 @@ namespace glm
this->value[3] = col_type(0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<3, 3, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -139,7 +139,7 @@ namespace glm
this->value[3] = col_type(0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<4, 4, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -148,7 +148,7 @@ namespace glm
this->value[3] = col_type(m[3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<2, 3, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -157,7 +157,7 @@ namespace glm
this->value[3] = col_type(0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<3, 2, T, P> const & m)
{
this->value[0] = col_type(m[0], 0);
@ -166,7 +166,7 @@ namespace glm
this->value[3] = col_type(0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<2, 4, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -175,7 +175,7 @@ namespace glm
this->value[3] = col_type(0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<4, 2, T, P> const & m)
{
this->value[0] = col_type(m[0], 0);
@ -184,7 +184,7 @@ namespace glm
this->value[3] = col_type(m[3], 0);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P>::mat(mat<3, 4, T, P> const & m)
{
this->value[0] = col_type(m[0]);
@ -195,14 +195,14 @@ namespace glm
// -- Accesses --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<4, 3, T, P>::col_type & mat<4, 3, T, P>::operator[](typename mat<4, 3, T, P>::length_type i)
{
assert(i < this->length());
return this->value[i];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<4, 3, T, P>::col_type const & mat<4, 3, T, P>::operator[](typename mat<4, 3, T, P>::length_type i) const
{
assert(i < this->length());
@ -212,7 +212,7 @@ namespace glm
// -- Unary updatable operators --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P>& mat<4, 3, T, P>::operator=(mat<4, 3, T, P> const & m)
{
this->value[0] = m[0];
@ -223,7 +223,7 @@ namespace glm
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 3, T, P>& mat<4, 3, T, P>::operator=(mat<4, 3, U, P> const & m)
{
@ -234,7 +234,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator+=(U s)
{
@ -245,7 +245,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator+=(mat<4, 3, U, P> const & m)
{
@ -256,7 +256,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator-=(U s)
{
@ -267,7 +267,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator-=(mat<4, 3, U, P> const & m)
{
@ -278,7 +278,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator*=(U s)
{
@ -289,7 +289,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator/=(U s)
{
@ -302,7 +302,7 @@ namespace glm
// -- Increment and decrement operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator++()
{
++this->value[0];
@ -312,7 +312,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> & mat<4, 3, T, P>::operator--()
{
--this->value[0];
@ -322,7 +322,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> mat<4, 3, T, P>::operator++(int)
{
mat<4, 3, T, P> Result(*this);
@ -330,7 +330,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> mat<4, 3, T, P>::operator--(int)
{
mat<4, 3, T, P> Result(*this);
@ -340,13 +340,13 @@ namespace glm
// -- Unary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator+(mat<4, 3, T, P> const & m)
{
return m;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator-(mat<4, 3, T, P> const & m)
{
return mat<4, 3, T, P>(
@ -358,7 +358,7 @@ namespace glm
// -- Binary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator+(mat<4, 3, T, P> const & m, T const & s)
{
return mat<4, 3, T, P>(
@ -368,7 +368,7 @@ namespace glm
m[3] + s);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator+(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2)
{
return mat<4, 3, T, P>(
@ -378,7 +378,7 @@ namespace glm
m1[3] + m2[3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator-(mat<4, 3, T, P> const & m, T const & s)
{
return mat<4, 3, T, P>(
@ -388,7 +388,7 @@ namespace glm
m[3] - s);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator-(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2)
{
return mat<4, 3, T, P>(
@ -398,7 +398,7 @@ namespace glm
m1[3] - m2[3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator*(mat<4, 3, T, P> const & m, T const & s)
{
return mat<4, 3, T, P>(
@ -408,7 +408,7 @@ namespace glm
m[3] * s);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator*(T const & s, mat<4, 3, T, P> const & m)
{
return mat<4, 3, T, P>(
@ -418,7 +418,7 @@ namespace glm
m[3] * s);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<4, 3, T, P>::col_type operator*
(
mat<4, 3, T, P> const& m,
@ -430,7 +430,7 @@ namespace glm
m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z + m[3][2] * v.w);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<4, 3, T, P>::row_type operator*
(
typename mat<4, 3, T, P>::col_type const & v,
@ -443,7 +443,7 @@ namespace glm
v.x * m[3][0] + v.y * m[3][1] + v.z * m[3][2]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 3, T, P> operator*(mat<4, 3, T, P> const & m1, mat<2, 4, T, P> const & m2)
{
return mat<2, 3, T, P>(
@ -455,7 +455,7 @@ namespace glm
m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> operator*(mat<4, 3, T, P> const & m1, mat<3, 4, T, P> const & m2)
{
T const SrcA00 = m1[0][0];
@ -497,7 +497,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator*(mat<4, 3, T, P> const & m1, mat<4, 4, T, P> const & m2)
{
return mat<4, 3, T, P>(
@ -515,7 +515,7 @@ namespace glm
m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2] + m1[3][2] * m2[3][3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator/(mat<4, 3, T, P> const & m, T const & s)
{
return mat<4, 3, T, P>(
@ -525,7 +525,7 @@ namespace glm
m[3] / s);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 3, T, P> operator/(T const & s, mat<4, 3, T, P> const & m)
{
return mat<4, 3, T, P>(
@ -537,13 +537,13 @@ namespace glm
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator==(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2)
{
return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator!=(mat<4, 3, T, P> const & m1, mat<4, 3, T, P> const & m2)
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);

50
glm/detail/type_mat4x4.hpp
View File

@ -11,7 +11,7 @@
namespace glm
{
template<typename T, precision P>
template<typename T, qualifier P>
struct mat<4, 4, T, P>
{
typedef vec<4, T, P> col_type;
@ -36,7 +36,7 @@ namespace glm
GLM_FUNC_DECL mat() GLM_DEFAULT;
GLM_FUNC_DECL mat(mat<4, 4, T, P> const& m) GLM_DEFAULT;
template<precision Q>
template<qualifier Q>
GLM_FUNC_DECL mat(mat<4, 4, T, Q> const& m);
GLM_FUNC_DECL explicit mat(T const & x);
@ -73,7 +73,7 @@ namespace glm
// -- Matrix conversions --
template<typename U, precision Q>
template<typename U, qualifier Q>
GLM_FUNC_DECL GLM_EXPLICIT mat(mat<4, 4, U, Q> const & m);
GLM_FUNC_DECL GLM_EXPLICIT mat(mat<2, 2, T, P> const & x);
@ -118,74 +118,74 @@ namespace glm
// -- Unary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> operator+(mat<4, 4, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> operator-(mat<4, 4, T, P> const & m);
// -- Binary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> operator+(mat<4, 4, T, P> const & m, T const & s);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> operator+(T const & s, mat<4, 4, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> operator+(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> operator-(mat<4, 4, T, P> const & m, T const & s);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> operator-(T const & s, mat<4, 4, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> operator-(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const& m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> operator*(mat<4, 4, T, P> const & m, T const & s);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> operator*(T const & s, mat<4, 4, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<4, 4, T, P>::col_type operator*(mat<4, 4, T, P> const & m, typename mat<4, 4, T, P>::row_type const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<4, 4, T, P>::row_type operator*(typename mat<4, 4, T, P>::col_type const & v, mat<4, 4, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<2, 4, T, P> operator*(mat<4, 4, T, P> const & m1, mat<2, 4, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 4, T, P> operator*(mat<4, 4, T, P> const & m1, mat<3, 4, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> operator*(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> operator/(mat<4, 4, T, P> const & m, T const & s);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> operator/(T const & s, mat<4, 4, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<4, 4, T, P>::col_type operator/(mat<4, 4, T, P> const & m, typename mat<4, 4, T, P>::row_type const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL typename mat<4, 4, T, P>::row_type operator/(typename mat<4, 4, T, P>::col_type const & v, mat<4, 4, T, P> const & m);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> operator/(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const& m2);
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator==(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator!=(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2);
}//namespace glm

114
glm/detail/type_mat4x4.inl
View File

@ -8,13 +8,13 @@ namespace glm
// -- Constructors --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat()
{}
# endif
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<4, 4, T, P> const & m)
{
this->value[0] = m[0];
@ -24,8 +24,8 @@ namespace glm
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<precision Q>
template<typename T, qualifier P>
template<qualifier Q>
GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<4, 4, T, Q> const & m)
{
this->value[0] = m[0];
@ -34,7 +34,7 @@ namespace glm
this->value[3] = m[3];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(T const & s)
{
this->value[0] = col_type(s, 0, 0, 0);
@ -43,7 +43,7 @@ namespace glm
this->value[3] = col_type(0, 0, 0, s);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat
(
T const & x0, T const & y0, T const & z0, T const & w0,
@ -58,7 +58,7 @@ namespace glm
this->value[3] = col_type(x3, y3, z3, w3);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat
(
col_type const & v0,
@ -73,8 +73,8 @@ namespace glm
this->value[3] = v3;
}
template<typename T, precision P>
template<typename U, precision Q>
template<typename T, qualifier P>
template<typename U, qualifier Q>
GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat
(
mat<4, 4, U, Q> const & m
@ -88,7 +88,7 @@ namespace glm
// -- Conversions --
template<typename T, precision P>
template<typename T, qualifier P>
template<
typename X1, typename Y1, typename Z1, typename W1,
typename X2, typename Y2, typename Z2, typename W2,
@ -128,7 +128,7 @@ namespace glm
this->value[3] = col_type(static_cast<T>(x4), value_type(y4), value_type(z4), value_type(w4));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename V1, typename V2, typename V3, typename V4>
GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat
(
@ -151,7 +151,7 @@ namespace glm
// -- Matrix conversions --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<2, 2, T, P> const & m)
{
this->value[0] = col_type(m[0], 0, 0);
@ -160,7 +160,7 @@ namespace glm
this->value[3] = col_type(0, 0, 0, 1);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<3, 3, T, P> const & m)
{
this->value[0] = col_type(m[0], 0);
@ -169,7 +169,7 @@ namespace glm
this->value[3] = col_type(0, 0, 0, 1);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<2, 3, T, P> const & m)
{
this->value[0] = col_type(m[0], 0);
@ -178,7 +178,7 @@ namespace glm
this->value[3] = col_type(0, 0, 0, 1);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<3, 2, T, P> const & m)
{
this->value[0] = col_type(m[0], 0, 0);
@ -187,7 +187,7 @@ namespace glm
this->value[3] = col_type(0, 0, 0, 1);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<2, 4, T, P> const & m)
{
this->value[0] = m[0];
@ -196,7 +196,7 @@ namespace glm
this->value[3] = col_type(0, 0, 0, 1);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<4, 2, T, P> const & m)
{
this->value[0] = col_type(m[0], 0, 0);
@ -205,7 +205,7 @@ namespace glm
this->value[3] = col_type(0, 0, 0, 1);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<3, 4, T, P> const & m)
{
this->value[0] = m[0];
@ -214,7 +214,7 @@ namespace glm
this->value[3] = col_type(0, 0, 0, 1);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P>::mat(mat<4, 3, T, P> const & m)
{
this->value[0] = col_type(m[0], 0);
@ -225,14 +225,14 @@ namespace glm
// -- Accesses --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<4, 4, T, P>::col_type & mat<4, 4, T, P>::operator[](typename mat<4, 4, T, P>::length_type i)
{
assert(i < this->length());
return this->value[i];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<4, 4, T, P>::col_type const & mat<4, 4, T, P>::operator[](typename mat<4, 4, T, P>::length_type i) const
{
assert(i < this->length());
@ -242,7 +242,7 @@ namespace glm
// -- Unary arithmetic operators --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P>& mat<4, 4, T, P>::operator=(mat<4, 4, T, P> const & m)
{
//memcpy could be faster
@ -255,7 +255,7 @@ namespace glm
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 4, T, P>& mat<4, 4, T, P>::operator=(mat<4, 4, U, P> const & m)
{
@ -268,7 +268,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 4, T, P>& mat<4, 4, T, P>::operator+=(U s)
{
@ -279,7 +279,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 4, T, P>& mat<4, 4, T, P>::operator+=(mat<4, 4, U, P> const & m)
{
@ -290,7 +290,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator-=(U s)
{
@ -301,7 +301,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator-=(mat<4, 4, U, P> const & m)
{
@ -312,7 +312,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator*=(U s)
{
@ -323,14 +323,14 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator*=(mat<4, 4, U, P> const & m)
{
return (*this = *this * m);
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator/=(U s)
{
@ -341,7 +341,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator/=(mat<4, 4, U, P> const & m)
{
@ -350,7 +350,7 @@ namespace glm
// -- Increment and decrement operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator++()
{
++this->value[0];
@ -360,7 +360,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> & mat<4, 4, T, P>::operator--()
{
--this->value[0];
@ -370,7 +370,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> mat<4, 4, T, P>::operator++(int)
{
mat<4, 4, T, P> Result(*this);
@ -378,7 +378,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> mat<4, 4, T, P>::operator--(int)
{
mat<4, 4, T, P> Result(*this);
@ -388,13 +388,13 @@ namespace glm
// -- Unary constant operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator+(mat<4, 4, T, P> const & m)
{
return m;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator-(mat<4, 4, T, P> const & m)
{
return mat<4, 4, T, P>(
@ -406,7 +406,7 @@ namespace glm
// -- Binary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator+(mat<4, 4, T, P> const & m, T const & s)
{
return mat<4, 4, T, P>(
@ -416,7 +416,7 @@ namespace glm
m[3] + s);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator+(T const & s, mat<4, 4, T, P> const & m)
{
return mat<4, 4, T, P>(
@ -426,7 +426,7 @@ namespace glm
m[3] + s);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator+(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2)
{
return mat<4, 4, T, P>(
@ -436,7 +436,7 @@ namespace glm
m1[3] + m2[3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator-(mat<4, 4, T, P> const & m, T const & s)
{
return mat<4, 4, T, P>(
@ -446,7 +446,7 @@ namespace glm
m[3] - s);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator-(T const & s, mat<4, 4, T, P> const & m)
{
return mat<4, 4, T, P>(
@ -456,7 +456,7 @@ namespace glm
s - m[3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator-(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2)
{
return mat<4, 4, T, P>(
@ -466,7 +466,7 @@ namespace glm
m1[3] - m2[3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator*(mat<4, 4, T, P> const & m, T const & s)
{
return mat<4, 4, T, P>(
@ -476,7 +476,7 @@ namespace glm
m[3] * s);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator*(T const & s, mat<4, 4, T, P> const & m)
{
return mat<4, 4, T, P>(
@ -486,7 +486,7 @@ namespace glm
m[3] * s);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<4, 4, T, P>::col_type operator*
(
mat<4, 4, T, P> const& m,
@ -534,7 +534,7 @@ namespace glm
*/
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<4, 4, T, P>::row_type operator*
(
typename mat<4, 4, T, P>::col_type const & v,
@ -548,7 +548,7 @@ namespace glm
m[3][0] * v[0] + m[3][1] * v[1] + m[3][2] * v[2] + m[3][3] * v[3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 4, T, P> operator*(mat<4, 4, T, P> const & m1, mat<2, 4, T, P> const & m2)
{
return mat<2, 4, T, P>(
@ -562,7 +562,7 @@ namespace glm
m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2] + m1[3][3] * m2[1][3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 4, T, P> operator*(mat<4, 4, T, P> const & m1, mat<3, 4, T, P> const & m2)
{
return mat<3, 4, T, P>(
@ -580,7 +580,7 @@ namespace glm
m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2] + m1[3][3] * m2[2][3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator*(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2)
{
typename mat<4, 4, T, P>::col_type const SrcA0 = m1[0];
@ -601,7 +601,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator/(mat<4, 4, T, P> const & m, T const & s)
{
return mat<4, 4, T, P>(
@ -611,7 +611,7 @@ namespace glm
m[3] / s);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator/(T const & s, mat<4, 4, T, P> const& m)
{
return mat<4, 4, T, P>(
@ -621,19 +621,19 @@ namespace glm
s / m[3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<4, 4, T, P>::col_type operator/(mat<4, 4, T, P> const & m, typename mat<4, 4, T, P>::row_type const & v)
{
return inverse(m) * v;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER typename mat<4, 4, T, P>::row_type operator/(typename mat<4, 4, T, P>::col_type const & v, mat<4, 4, T, P> const & m)
{
return v * inverse(m);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> operator/(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2)
{
mat<4, 4, T, P> m1_copy(m1);
@ -642,13 +642,13 @@ namespace glm
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator==(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2)
{
return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator!=(mat<4, 4, T, P> const & m1, mat<4, 4, T, P> const & m2)
{
return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);

160
glm/detail/type_vec.hpp
View File

@ -3,7 +3,7 @@
#pragma once
#include "precision.hpp"
#include "qualifier.hpp"
#include "type_int.hpp"
#include "compute_vector_relational.hpp"
@ -103,10 +103,10 @@ namespace detail
}//namespace detail
#if GLM_HAS_TEMPLATE_ALIASES
template <typename T, precision P = defaultp> using tvec1 = vec<1, T, P>;
template <typename T, precision P = defaultp> using tvec2 = vec<2, T, P>;
template <typename T, precision P = defaultp> using tvec3 = vec<3, T, P>;
template <typename T, precision P = defaultp> using tvec4 = vec<4, T, P>;
template <typename T, qualifier P = defaultp> using tvec1 = vec<1, T, P>;
template <typename T, qualifier P = defaultp> using tvec2 = vec<2, T, P>;
template <typename T, qualifier P = defaultp> using tvec3 = vec<3, T, P>;
template <typename T, qualifier P = defaultp> using tvec4 = vec<4, T, P>;
#endif//GLM_HAS_TEMPLATE_ALIASES
typedef vec<1, float, highp> highp_vec1_t;
@ -128,106 +128,106 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// 2 components vector of high single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of high single-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, float, highp> highp_vec2;
/// 2 components vector of medium single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of medium single-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, float, mediump> mediump_vec2;
/// 2 components vector of low single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of low single-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, float, lowp> lowp_vec2;
/// 2 components vector of high double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of high double-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, double, highp> highp_dvec2;
/// 2 components vector of medium double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of medium double-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, double, mediump> mediump_dvec2;
/// 2 components vector of low double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of low double-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, double, lowp> lowp_dvec2;
/// 2 components vector of high precision signed integer numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of high qualifier signed integer numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, int, highp> highp_ivec2;
/// 2 components vector of medium precision signed integer numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of medium qualifier signed integer numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, int, mediump> mediump_ivec2;
/// 2 components vector of low precision signed integer numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of low qualifier signed integer numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, int, lowp> lowp_ivec2;
/// 2 components vector of high precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of high qualifier unsigned integer numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, uint, highp> highp_uvec2;
/// 2 components vector of medium precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of medium qualifier unsigned integer numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, uint, mediump> mediump_uvec2;
/// 2 components vector of low precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of low qualifier unsigned integer numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, uint, lowp> lowp_uvec2;
/// 2 components vector of high precision bool numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of high qualifier bool numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, bool, highp> highp_bvec2;
/// 2 components vector of medium precision bool numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of medium qualifier bool numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<2, bool, mediump> mediump_bvec2;
/// 2 components vector of low precision bool numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of low qualifier bool numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
@ -238,103 +238,103 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// 3 components vector of high single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of high single-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, float, highp> highp_vec3;
/// 3 components vector of medium single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of medium single-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, float, mediump> mediump_vec3;
/// 3 components vector of low single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of low single-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, float, lowp> lowp_vec3;
/// 3 components vector of high double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of high double-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, double, highp> highp_dvec3;
/// 3 components vector of medium double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of medium double-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, double, mediump> mediump_dvec3;
/// 3 components vector of low double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of low double-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, double, lowp> lowp_dvec3;
/// 3 components vector of high precision signed integer numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of high qualifier signed integer numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, int, highp> highp_ivec3;
/// 3 components vector of medium precision signed integer numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of medium qualifier signed integer numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, int, mediump> mediump_ivec3;
/// 3 components vector of low precision signed integer numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of low qualifier signed integer numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, int, lowp> lowp_ivec3;
/// 3 components vector of high precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of high qualifier unsigned integer numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, uint, highp> highp_uvec3;
/// 3 components vector of medium precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of medium qualifier unsigned integer numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, uint, mediump> mediump_uvec3;
/// 3 components vector of low precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of low qualifier unsigned integer numbers.
/// There is no guarantee on the actual qualifier.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, uint, lowp> lowp_uvec3;
/// 3 components vector of high precision bool numbers.
/// 3 components vector of high qualifier bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, bool, highp> highp_bvec3;
/// 3 components vector of medium precision bool numbers.
/// 3 components vector of medium qualifier bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<3, bool, mediump> mediump_bvec3;
/// 3 components vector of low precision bool numbers.
/// 3 components vector of low qualifier bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
@ -345,91 +345,91 @@ namespace detail
/// @addtogroup core_precision
/// @{
/// 4 components vector of high single-precision floating-point numbers.
/// 4 components vector of high single-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, float, highp> highp_vec4;
/// 4 components vector of medium single-precision floating-point numbers.
/// 4 components vector of medium single-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, float, mediump> mediump_vec4;
/// 4 components vector of low single-precision floating-point numbers.
/// 4 components vector of low single-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, float, lowp> lowp_vec4;
/// 4 components vector of high double-precision floating-point numbers.
/// 4 components vector of high double-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, double, highp> highp_dvec4;
/// 4 components vector of medium double-precision floating-point numbers.
/// 4 components vector of medium double-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, double, mediump> mediump_dvec4;
/// 4 components vector of low double-precision floating-point numbers.
/// 4 components vector of low double-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, double, lowp> lowp_dvec4;
/// 4 components vector of high precision signed integer numbers.
/// 4 components vector of high qualifier signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, int, highp> highp_ivec4;
/// 4 components vector of medium precision signed integer numbers.
/// 4 components vector of medium qualifier signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, int, mediump> mediump_ivec4;
/// 4 components vector of low precision signed integer numbers.
/// 4 components vector of low qualifier signed integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, int, lowp> lowp_ivec4;
/// 4 components vector of high precision unsigned integer numbers.
/// 4 components vector of high qualifier unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, uint, highp> highp_uvec4;
/// 4 components vector of medium precision unsigned integer numbers.
/// 4 components vector of medium qualifier unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, uint, mediump> mediump_uvec4;
/// 4 components vector of low precision unsigned integer numbers.
/// 4 components vector of low qualifier unsigned integer numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, uint, lowp> lowp_uvec4;
/// 4 components vector of high precision bool numbers.
/// 4 components vector of high qualifier bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, bool, highp> highp_bvec4;
/// 4 components vector of medium precision bool numbers.
/// 4 components vector of medium qualifier bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
typedef vec<4, bool, mediump> mediump_bvec4;
/// 4 components vector of low precision bool numbers.
/// 4 components vector of low qualifier bool numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
@ -478,17 +478,17 @@ namespace detail
typedef mediump_dvec3 dvec3;
typedef mediump_dvec4 dvec4;
#else //defined(GLM_PRECISION_HIGHP_DOUBLE)
/// 2 components vector of double-precision floating-point numbers.
/// 2 components vector of double-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef highp_dvec2 dvec2;
//! 3 components vector of double-precision floating-point numbers.
//! 3 components vector of double-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef highp_dvec3 dvec3;
//! 4 components vector of double-precision floating-point numbers.
//! 4 components vector of double-qualifier floating-point numbers.
///
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
typedef highp_dvec4 dvec4;

86
glm/detail/type_vec1.hpp
View File

@ -16,7 +16,7 @@
namespace glm
{
template<typename T, precision P>
template<typename T, qualifier P>
struct vec<1, T, P>
{
// -- Implementation detail --
@ -87,7 +87,7 @@ namespace glm
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec() GLM_DEFAULT;
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec const& v) GLM_DEFAULT;
template<precision Q>
template<qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<1, T, Q> const& v);
// -- Explicit basic constructors --
@ -97,17 +97,17 @@ namespace glm
// -- Conversion vector constructors --
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename U, precision Q>
template<typename U, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<2, U, Q> const& v);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename U, precision Q>
template<typename U, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<3, U, Q> const& v);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename U, precision Q>
template<typename U, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<4, U, Q> const& v);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename U, precision Q>
template<typename U, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<1, U, Q> const& v);
// -- Swizzle constructors --
@ -180,119 +180,119 @@ namespace glm
// -- Unary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator+(vec<1, T, P> const& v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator-(vec<1, T, P> const& v);
// -- Binary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator+(vec<1, T, P> const& v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator+(T scalar, vec<1, T, P> const& v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator+(vec<1, T, P> const& v1, vec<1, T, P> const& v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator-(vec<1, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator-(T scalar, vec<1, T, P> const& v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator-(vec<1, T, P> const& v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator*(vec<1, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator*(T scalar, vec<1, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator*(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator/(vec<1, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator/(T scalar, vec<1, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator/(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator%(vec<1, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator%(T scalar, vec<1, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator%(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator&(vec<1, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator&(T scalar, vec<1, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator&(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator|(vec<1, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator|(T scalar, vec<1, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator|(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator^(vec<1, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator^(T scalar, vec<1, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator^(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator<<(vec<1, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator<<(T scalar, vec<1, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator<<(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator>>(vec<1, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator>>(T scalar, vec<1, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator>>(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<1, T, P> operator~(vec<1, T, P> const & v);
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator==(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator!=(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
template<precision P>
template<qualifier P>
GLM_FUNC_DECL vec<1, bool, P> operator&&(vec<1, bool, P> const & v1, vec<1, bool, P> const & v2);
template<precision P>
template<qualifier P>
GLM_FUNC_DECL vec<1, bool, P> operator||(vec<1, bool, P> const & v1, vec<1, bool, P> const & v2);
}//namespace glm

156
glm/detail/type_vec1.inl
View File

@ -6,67 +6,67 @@ namespace glm
// -- Implicit basic constructors --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, P>::vec()
{}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, P>::vec(vec<1, T, P> const & v)
: x(v.x)
{}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<precision Q>
template<typename T, qualifier P>
template<qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, P>::vec(vec<1, T, Q> const& v)
: x(v.x)
{}
// -- Explicit basic constructors --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, P>::vec(T scalar)
: x(scalar)
{}
// -- Conversion vector constructors --
template<typename T, precision P>
template<typename U, precision Q>
template<typename T, qualifier P>
template<typename U, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, P>::vec(vec<1, U, Q> const & v)
: x(static_cast<T>(v.x))
{}
template<typename T, precision P>
template<typename U, precision Q>
template<typename T, qualifier P>
template<typename U, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, P>::vec(vec<2, U, Q> const & v)
: x(static_cast<T>(v.x))
{}
template<typename T, precision P>
template<typename U, precision Q>
template<typename T, qualifier P>
template<typename U, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, P>::vec(vec<3, U, Q> const & v)
: x(static_cast<T>(v.x))
{}
template<typename T, precision P>
template<typename U, precision Q>
template<typename T, qualifier P>
template<typename U, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, P>::vec(vec<4, U, Q> const & v)
: x(static_cast<T>(v.x))
{}
// -- Component accesses --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T & vec<1, T, P>::operator[](typename vec<1, T, P>::length_type i)
{
assert(i >= 0 && i < this->length());
return (&x)[i];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T const & vec<1, T, P>::operator[](typename vec<1, T, P>::length_type i) const
{
assert(i >= 0 && i < this->length());
@ -76,7 +76,7 @@ namespace glm
// -- Unary arithmetic operators --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator=(vec<1, T, P> const & v)
{
this->x = v.x;
@ -84,7 +84,7 @@ namespace glm
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator=(vec<1, U, P> const & v)
{
@ -92,7 +92,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator+=(U scalar)
{
@ -100,7 +100,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator+=(vec<1, U, P> const & v)
{
@ -108,7 +108,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator-=(U scalar)
{
@ -116,7 +116,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator-=(vec<1, U, P> const & v)
{
@ -124,7 +124,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator*=(U scalar)
{
@ -132,7 +132,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator*=(vec<1, U, P> const & v)
{
@ -140,7 +140,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator/=(U scalar)
{
@ -148,7 +148,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator/=(vec<1, U, P> const & v)
{
@ -158,21 +158,21 @@ namespace glm
// -- Increment and decrement operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator++()
{
++this->x;
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator--()
{
--this->x;
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> vec<1, T, P>::operator++(int)
{
vec<1, T, P> Result(*this);
@ -180,7 +180,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> vec<1, T, P>::operator--(int)
{
vec<1, T, P> Result(*this);
@ -190,7 +190,7 @@ namespace glm
// -- Unary bit operators --
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator%=(U scalar)
{
@ -198,7 +198,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator%=(vec<1, U, P> const & v)
{
@ -206,7 +206,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator&=(U scalar)
{
@ -214,7 +214,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator&=(vec<1, U, P> const & v)
{
@ -222,7 +222,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator|=(U scalar)
{
@ -230,7 +230,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator|=(vec<1, U, P> const & v)
{
@ -238,7 +238,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator^=(U scalar)
{
@ -246,7 +246,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator^=(vec<1, U, P> const & v)
{
@ -254,7 +254,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator<<=(U scalar)
{
@ -262,7 +262,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator<<=(vec<1, U, P> const & v)
{
@ -270,7 +270,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator>>=(U scalar)
{
@ -278,7 +278,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator>>=(vec<1, U, P> const & v)
{
@ -288,13 +288,13 @@ namespace glm
// -- Unary constant operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator+(vec<1, T, P> const & v)
{
return v;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator-(vec<1, T, P> const & v)
{
return vec<1, T, P>(
@ -303,21 +303,21 @@ namespace glm
// -- Binary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator+(vec<1, T, P> const & v, T scalar)
{
return vec<1, T, P>(
v.x + scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator+(T scalar, vec<1, T, P> const & v)
{
return vec<1, T, P>(
scalar + v.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator+(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<1, T, P>(
@ -325,63 +325,63 @@ namespace glm
}
//operator-
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator-(vec<1, T, P> const & v, T scalar)
{
return vec<1, T, P>(
v.x - scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator-(T scalar, vec<1, T, P> const & v)
{
return vec<1, T, P>(
scalar - v.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator-(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<1, T, P>(
v1.x - v2.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator*(vec<1, T, P> const & v, T scalar)
{
return vec<1, T, P>(
v.x * scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator*(T scalar, vec<1, T, P> const & v)
{
return vec<1, T, P>(
scalar * v.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator*(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<1, T, P>(
v1.x * v2.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator/(vec<1, T, P> const & v, T scalar)
{
return vec<1, T, P>(
v.x / scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator/(T scalar, vec<1, T, P> const & v)
{
return vec<1, T, P>(
scalar / v.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator/(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<1, T, P>(
@ -390,133 +390,133 @@ namespace glm
// -- Binary bit operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator%(vec<1, T, P> const & v, T scalar)
{
return vec<1, T, P>(
v.x % scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator%(T scalar, vec<1, T, P> const & v)
{
return vec<1, T, P>(
scalar % v.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator%(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<1, T, P>(
v1.x % v2.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator&(vec<1, T, P> const & v, T scalar)
{
return vec<1, T, P>(
v.x & scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator&(T scalar, vec<1, T, P> const & v)
{
return vec<1, T, P>(
scalar & v.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator&(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<1, T, P>(
v1.x & v2.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator|(vec<1, T, P> const & v, T scalar)
{
return vec<1, T, P>(
v.x | scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator|(T scalar, vec<1, T, P> const & v)
{
return vec<1, T, P>(
scalar | v.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator|(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<1, T, P>(
v1.x | v2.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator^(vec<1, T, P> const & v, T scalar)
{
return vec<1, T, P>(
v.x ^ scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator^(T scalar, vec<1, T, P> const & v)
{
return vec<1, T, P>(
scalar ^ v.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator^(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<1, T, P>(
v1.x ^ v2.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator<<(vec<1, T, P> const & v, T scalar)
{
return vec<1, T, P>(
static_cast<T>(v.x << scalar));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator<<(T scalar, vec<1, T, P> const & v)
{
return vec<1, T, P>(
scalar << v.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator<<(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<1, T, P>(
v1.x << v2.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator>>(vec<1, T, P> const & v, T scalar)
{
return vec<1, T, P>(
v.x >> scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator>>(T scalar, vec<1, T, P> const & v)
{
return vec<1, T, P>(
scalar >> v.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator>>(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<1, T, P>(
v1.x >> v2.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<1, T, P> operator~(vec<1, T, P> const & v)
{
return vec<1, T, P>(
@ -525,25 +525,25 @@ namespace glm
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator==(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{
return detail::compute_equal<T>::call(v1.x, v2.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator!=(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{
return !(v1 == v2);
}
template<precision P>
template<qualifier P>
GLM_FUNC_QUALIFIER vec<1, bool, P> operator&&(vec<1, bool, P> const & v1, vec<1, bool, P> const & v2)
{
return vec<1, bool, P>(v1.x && v2.x);
}
template<precision P>
template<qualifier P>
GLM_FUNC_QUALIFIER vec<1, bool, P> operator||(vec<1, bool, P> const & v1, vec<1, bool, P> const & v2)
{
return vec<1, bool, P>(v1.x || v2.x);

124
glm/detail/type_vec2.hpp
View File

@ -15,7 +15,7 @@
namespace glm
{
template<typename T, precision P>
template<typename T, qualifier P>
struct vec<2, T, P>
{
// -- Implementation detail --
@ -88,7 +88,7 @@ namespace glm
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec() GLM_DEFAULT;
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec const& v) GLM_DEFAULT;
template<precision Q>
template<qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<2, T, Q> const& v);
// -- Explicit basic constructors --
@ -107,14 +107,14 @@ namespace glm
// -- Conversion vector constructors --
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename U, precision Q>
template<typename U, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<3, U, Q> const& v);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename U, precision Q>
template<typename U, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<4, U, Q> const& v);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename U, precision Q>
template<typename U, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<2, U, Q> const& v);
// -- Swizzle constructors --
@ -206,179 +206,179 @@ namespace glm
// -- Unary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator+(vec<2, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator-(vec<2, T, P> const & v);
// -- Binary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator+(vec<2, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator+(vec<2, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator+(T scalar, vec<2, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator+(vec<1, T, P> const & v1, vec<2, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator+(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator-(vec<2, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator-(vec<2, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator-(T scalar, vec<2, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator-(vec<1, T, P> const & v1, vec<2, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator-(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator*(vec<2, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator*(vec<2, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator*(T scalar, vec<2, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator*(vec<1, T, P> const & v1, vec<2, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator*(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator/(vec<2, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator/(vec<2, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator/(T scalar, vec<2, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator/(vec<1, T, P> const & v1, vec<2, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator/(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator%(vec<2, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator%(vec<2, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator%(T scalar, vec<2, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator%(vec<1, T, P> const & v1, vec<2, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator%(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator&(vec<2, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator&(vec<2, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator&(T scalar, vec<2, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator&(vec<1, T, P> const & v1, vec<2, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator&(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator|(vec<2, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator|(vec<2, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator|(T scalar, vec<2, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator|(vec<1, T, P> const & v1, vec<2, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator|(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator^(vec<2, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator^(vec<2, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator^(T scalar, vec<2, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator^(vec<1, T, P> const & v1, vec<2, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator^(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator<<(vec<2, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator<<(vec<2, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator<<(T scalar, vec<2, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator<<(vec<1, T, P> const & v1, vec<2, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator<<(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator>>(vec<2, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator>>(vec<2, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator>>(T scalar, vec<2, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator>>(vec<1, T, P> const & v1, vec<2, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator>>(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> operator~(vec<2, T, P> const & v);
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator==(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator!=(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
template<precision P>
template<qualifier P>
GLM_FUNC_DECL vec<2, bool, P> operator&&(vec<2, bool, P> const & v1, vec<2, bool, P> const & v2);
template<precision P>
template<qualifier P>
GLM_FUNC_DECL vec<2, bool, P> operator||(vec<2, bool, P> const & v1, vec<2, bool, P> const & v2);
}//namespace glm

218
glm/detail/type_vec2.inl
View File

@ -6,46 +6,46 @@ namespace glm
// -- Implicit basic constructors --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, P>::vec()
{}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, P>::vec(vec<2, T, P> const& v)
: x(v.x), y(v.y)
{}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<precision Q>
template<typename T, qualifier P>
template<qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, P>::vec(vec<2, T, Q> const& v)
: x(v.x), y(v.y)
{}
// -- Explicit basic constructors --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, P>::vec(T scalar)
: x(scalar), y(scalar)
{}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, P>::vec(T _x, T _y)
: x(_x), y(_y)
{}
// -- Conversion scalar constructors --
template<typename T, precision P>
template<typename T, qualifier P>
template<typename A, typename B>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, P>::vec(A _x, B _y)
: x(static_cast<T>(_x))
, y(static_cast<T>(_y))
{}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename A, typename B>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, P>::vec(vec<1, A, P> const& _x, vec<1, B, P> const& _y)
: x(static_cast<T>(_x.x))
@ -54,22 +54,22 @@ namespace glm
// -- Conversion vector constructors --
template<typename T, precision P>
template<typename U, precision Q>
template<typename T, qualifier P>
template<typename U, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, P>::vec(vec<2, U, Q> const& v)
: x(static_cast<T>(v.x))
, y(static_cast<T>(v.y))
{}
template<typename T, precision P>
template<typename U, precision Q>
template<typename T, qualifier P>
template<typename U, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, P>::vec(vec<3, U, Q> const& v)
: x(static_cast<T>(v.x))
, y(static_cast<T>(v.y))
{}
template<typename T, precision P>
template<typename U, precision Q>
template<typename T, qualifier P>
template<typename U, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, P>::vec(vec<4, U, Q> const& v)
: x(static_cast<T>(v.x))
, y(static_cast<T>(v.y))
@ -77,14 +77,14 @@ namespace glm
// -- Component accesses --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T & vec<2, T, P>::operator[](typename vec<2, T, P>::length_type i)
{
assert(i >= 0 && i < this->length());
return (&x)[i];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T const & vec<2, T, P>::operator[](typename vec<2, T, P>::length_type i) const
{
assert(i >= 0 && i < this->length());
@ -94,7 +94,7 @@ namespace glm
// -- Unary arithmetic operators --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator=(vec<2, T, P> const& v)
{
this->x = v.x;
@ -103,7 +103,7 @@ namespace glm
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator=(vec<2, U, P> const& v)
{
@ -112,7 +112,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator+=(U scalar)
{
@ -121,7 +121,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator+=(vec<1, U, P> const& v)
{
@ -130,7 +130,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator+=(vec<2, U, P> const& v)
{
@ -139,7 +139,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator-=(U scalar)
{
@ -148,7 +148,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator-=(vec<1, U, P> const& v)
{
@ -157,7 +157,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator-=(vec<2, U, P> const& v)
{
@ -166,7 +166,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator*=(U scalar)
{
@ -175,7 +175,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator*=(vec<1, U, P> const& v)
{
@ -184,7 +184,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator*=(vec<2, U, P> const& v)
{
@ -193,7 +193,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator/=(U scalar)
{
@ -202,7 +202,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator/=(vec<1, U, P> const& v)
{
@ -211,7 +211,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator/=(vec<2, U, P> const& v)
{
@ -222,7 +222,7 @@ namespace glm
// -- Increment and decrement operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator++()
{
++this->x;
@ -230,7 +230,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator--()
{
--this->x;
@ -238,7 +238,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> vec<2, T, P>::operator++(int)
{
vec<2, T, P> Result(*this);
@ -246,7 +246,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> vec<2, T, P>::operator--(int)
{
vec<2, T, P> Result(*this);
@ -256,7 +256,7 @@ namespace glm
// -- Unary bit operators --
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator%=(U scalar)
{
@ -265,7 +265,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator%=(vec<1, U, P> const& v)
{
@ -274,7 +274,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator%=(vec<2, U, P> const& v)
{
@ -283,7 +283,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator&=(U scalar)
{
@ -292,7 +292,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator&=(vec<1, U, P> const& v)
{
@ -301,7 +301,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator&=(vec<2, U, P> const& v)
{
@ -310,7 +310,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator|=(U scalar)
{
@ -319,7 +319,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator|=(vec<1, U, P> const& v)
{
@ -328,7 +328,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator|=(vec<2, U, P> const& v)
{
@ -337,7 +337,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator^=(U scalar)
{
@ -346,7 +346,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator^=(vec<1, U, P> const& v)
{
@ -355,7 +355,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator^=(vec<2, U, P> const& v)
{
@ -364,7 +364,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator<<=(U scalar)
{
@ -373,7 +373,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator<<=(vec<1, U, P> const& v)
{
@ -382,7 +382,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator<<=(vec<2, U, P> const& v)
{
@ -391,7 +391,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator>>=(U scalar)
{
@ -400,7 +400,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator>>=(vec<1, U, P> const& v)
{
@ -409,7 +409,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator>>=(vec<2, U, P> const& v)
{
@ -420,13 +420,13 @@ namespace glm
// -- Unary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator+(vec<2, T, P> const& v)
{
return v;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator-(vec<2, T, P> const& v)
{
return vec<2, T, P>(
@ -436,7 +436,7 @@ namespace glm
// -- Binary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator+(vec<2, T, P> const& v, T scalar)
{
return vec<2, T, P>(
@ -444,7 +444,7 @@ namespace glm
v.y + scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator+(vec<2, T, P> const& v1, vec<1, T, P> const& v2)
{
return vec<2, T, P>(
@ -452,7 +452,7 @@ namespace glm
v1.y + v2.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator+(T scalar, vec<2, T, P> const& v)
{
return vec<2, T, P>(
@ -460,7 +460,7 @@ namespace glm
scalar + v.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator+(vec<1, T, P> const& v1, vec<2, T, P> const& v2)
{
return vec<2, T, P>(
@ -468,7 +468,7 @@ namespace glm
v1.x + v2.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator+(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{
return vec<2, T, P>(
@ -476,7 +476,7 @@ namespace glm
v1.y + v2.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator-(vec<2, T, P> const & v, T scalar)
{
return vec<2, T, P>(
@ -484,7 +484,7 @@ namespace glm
v.y - scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator-(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<2, T, P>(
@ -492,7 +492,7 @@ namespace glm
v1.y - v2.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator-(T scalar, vec<2, T, P> const & v)
{
return vec<2, T, P>(
@ -500,7 +500,7 @@ namespace glm
scalar - v.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator-(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
{
return vec<2, T, P>(
@ -508,7 +508,7 @@ namespace glm
v1.x - v2.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator-(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{
return vec<2, T, P>(
@ -516,7 +516,7 @@ namespace glm
v1.y - v2.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator*(vec<2, T, P> const & v, T scalar)
{
return vec<2, T, P>(
@ -524,7 +524,7 @@ namespace glm
v.y * scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator*(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<2, T, P>(
@ -532,7 +532,7 @@ namespace glm
v1.y * v2.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator*(T scalar, vec<2, T, P> const & v)
{
return vec<2, T, P>(
@ -540,7 +540,7 @@ namespace glm
scalar * v.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator*(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
{
return vec<2, T, P>(
@ -548,7 +548,7 @@ namespace glm
v1.x * v2.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator*(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{
return vec<2, T, P>(
@ -556,7 +556,7 @@ namespace glm
v1.y * v2.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator/(vec<2, T, P> const & v, T scalar)
{
return vec<2, T, P>(
@ -564,7 +564,7 @@ namespace glm
v.y / scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator/(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<2, T, P>(
@ -572,7 +572,7 @@ namespace glm
v1.y / v2.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator/(T scalar, vec<2, T, P> const & v)
{
return vec<2, T, P>(
@ -580,7 +580,7 @@ namespace glm
scalar / v.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator/(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
{
return vec<2, T, P>(
@ -588,7 +588,7 @@ namespace glm
v1.x / v2.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator/(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{
return vec<2, T, P>(
@ -598,7 +598,7 @@ namespace glm
// -- Binary bit operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator%(vec<2, T, P> const & v, T scalar)
{
return vec<2, T, P>(
@ -606,7 +606,7 @@ namespace glm
v.y % scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator%(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<2, T, P>(
@ -614,7 +614,7 @@ namespace glm
v1.y % v2.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator%(T scalar, vec<2, T, P> const & v)
{
return vec<2, T, P>(
@ -622,7 +622,7 @@ namespace glm
scalar % v.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator%(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
{
return vec<2, T, P>(
@ -630,7 +630,7 @@ namespace glm
v1.x % v2.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator%(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{
return vec<2, T, P>(
@ -638,7 +638,7 @@ namespace glm
v1.y % v2.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator&(vec<2, T, P> const & v, T scalar)
{
return vec<2, T, P>(
@ -646,7 +646,7 @@ namespace glm
v.y & scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator&(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<2, T, P>(
@ -654,7 +654,7 @@ namespace glm
v1.y & v2.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator&(T scalar, vec<2, T, P> const & v)
{
return vec<2, T, P>(
@ -662,7 +662,7 @@ namespace glm
scalar & v.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator&(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
{
return vec<2, T, P>(
@ -670,7 +670,7 @@ namespace glm
v1.x & v2.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator&(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{
return vec<2, T, P>(
@ -678,7 +678,7 @@ namespace glm
v1.y & v2.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator|(vec<2, T, P> const & v, T scalar)
{
return vec<2, T, P>(
@ -686,7 +686,7 @@ namespace glm
v.y | scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator|(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<2, T, P>(
@ -694,7 +694,7 @@ namespace glm
v1.y | v2.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator|(T scalar, vec<2, T, P> const & v)
{
return vec<2, T, P>(
@ -702,7 +702,7 @@ namespace glm
scalar | v.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator|(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
{
return vec<2, T, P>(
@ -710,7 +710,7 @@ namespace glm
v1.x | v2.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator|(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{
return vec<2, T, P>(
@ -718,7 +718,7 @@ namespace glm
v1.y | v2.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator^(vec<2, T, P> const & v, T scalar)
{
return vec<2, T, P>(
@ -726,7 +726,7 @@ namespace glm
v.y ^ scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator^(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<2, T, P>(
@ -734,7 +734,7 @@ namespace glm
v1.y ^ v2.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator^(T scalar, vec<2, T, P> const & v)
{
return vec<2, T, P>(
@ -742,7 +742,7 @@ namespace glm
scalar ^ v.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator^(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
{
return vec<2, T, P>(
@ -750,7 +750,7 @@ namespace glm
v1.x ^ v2.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator^(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{
return vec<2, T, P>(
@ -758,7 +758,7 @@ namespace glm
v1.y ^ v2.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator<<(vec<2, T, P> const & v, T scalar)
{
return vec<2, T, P>(
@ -766,7 +766,7 @@ namespace glm
v.y << scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator<<(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<2, T, P>(
@ -774,7 +774,7 @@ namespace glm
v1.y << v2.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator<<(T scalar, vec<2, T, P> const & v)
{
return vec<2, T, P>(
@ -782,7 +782,7 @@ namespace glm
scalar << v.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator<<(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
{
return vec<2, T, P>(
@ -790,7 +790,7 @@ namespace glm
v1.x << v2.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator<<(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{
return vec<2, T, P>(
@ -798,7 +798,7 @@ namespace glm
v1.y << v2.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator>>(vec<2, T, P> const & v, T scalar)
{
return vec<2, T, P>(
@ -806,7 +806,7 @@ namespace glm
v.y >> scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator>>(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<2, T, P>(
@ -814,7 +814,7 @@ namespace glm
v1.y >> v2.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator>>(T scalar, vec<2, T, P> const & v)
{
return vec<2, T, P>(
@ -822,7 +822,7 @@ namespace glm
scalar >> v.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator>>(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
{
return vec<2, T, P>(
@ -830,7 +830,7 @@ namespace glm
v1.x >> v2.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator>>(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{
return vec<2, T, P>(
@ -838,7 +838,7 @@ namespace glm
v1.y >> v2.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> operator~(vec<2, T, P> const & v)
{
return vec<2, T, P>(
@ -848,7 +848,7 @@ namespace glm
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator==(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{
return
@ -856,19 +856,19 @@ namespace glm
detail::compute_equal<T>::call(v1.y, v2.y);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator!=(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{
return !(v1 == v2);
}
template<precision P>
template<qualifier P>
GLM_FUNC_QUALIFIER vec<2, bool, P> operator&&(vec<2, bool, P> const & v1, vec<2, bool, P> const & v2)
{
return vec<2, bool, P>(v1.x && v2.x, v1.y && v2.y);
}
template<precision P>
template<qualifier P>
GLM_FUNC_QUALIFIER vec<2, bool, P> operator||(vec<2, bool, P> const & v1, vec<2, bool, P> const & v2)
{
return vec<2, bool, P>(v1.x || v2.x, v1.y || v2.y);

130
glm/detail/type_vec3.hpp
View File

@ -15,7 +15,7 @@
namespace glm
{
template<typename T, precision P>
template<typename T, qualifier P>
struct vec<3, T, P>
{
// -- Implementation detail --
@ -88,7 +88,7 @@ namespace glm
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec() GLM_DEFAULT;
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec const & v) GLM_DEFAULT;
template<precision Q>
template<qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<3, T, Q> const & v);
// -- Explicit basic constructors --
@ -107,23 +107,23 @@ namespace glm
// -- Conversion vector constructors --
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename A, typename B, precision Q>
template<typename A, typename B, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<2, A, Q> const& _xy, B _z);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename A, typename B, precision Q>
template<typename A, typename B, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<2, A, Q> const& _xy, vec<1, B, Q> const& _z);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename A, typename B, precision Q>
template<typename A, typename B, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(A _x, vec<2, B, Q> const& _yz);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename A, typename B, precision Q>
template<typename A, typename B, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<1, A, Q> const& _x, vec<2, B, Q> const& _yz);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename U, precision Q>
template<typename U, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<4, U, Q> const& v);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename U, precision Q>
template<typename U, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<3, U, Q> const& v);
// -- Swizzle constructors --
@ -227,179 +227,179 @@ namespace glm
// -- Unary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator+(vec<3, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator-(vec<3, T, P> const & v);
// -- Binary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator+(vec<3, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator+(vec<3, T, P> const & v, vec<1, T, P> const & scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator+(T scalar, vec<3, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator+(vec<1, T, P> const & v1, vec<3, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator+(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator-(vec<3, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator-(vec<3, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator-(T scalar, vec<3, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator-(vec<1, T, P> const & v1, vec<3, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator-(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator*(vec<3, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator*(vec<3, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator*(T scalar, vec<3, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator*(vec<1, T, P> const & v1, vec<3, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator*(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator/(vec<3, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator/(vec<3, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator/(T scalar, vec<3, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator/(vec<1, T, P> const & v1, vec<3, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator/(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator%(vec<3, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator%(vec<3, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator%(T const & scalar, vec<3, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator%(vec<1, T, P> const & v1, vec<3, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator%(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator&(vec<3, T, P> const & v1, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator&(vec<3, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator&(T scalar, vec<3, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator&(vec<1, T, P> const & v1, vec<3, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator&(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator|(vec<3, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator|(vec<3, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator|(T scalar, vec<3, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator|(vec<1, T, P> const & v1, vec<3, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator|(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator^(vec<3, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator^(vec<3, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator^(T scalar, vec<3, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator^(vec<1, T, P> const & v1, vec<3, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator^(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator<<(vec<3, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator<<(vec<3, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator<<(T scalar, vec<3, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator<<(vec<1, T, P> const & v1, vec<3, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator<<(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator>>(vec<3, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator>>(vec<3, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator>>(T scalar, vec<3, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator>>(vec<1, T, P> const & v1, vec<3, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator>>(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator~(vec<3, T, P> const & v);
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator==(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator!=(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
template<precision P>
template<qualifier P>
GLM_FUNC_DECL vec<3, bool, P> operator&&(vec<3, bool, P> const & v1, vec<3, bool, P> const & v2);
template<precision P>
template<qualifier P>
GLM_FUNC_DECL vec<3, bool, P> operator||(vec<3, bool, P> const & v1, vec<3, bool, P> const & v2);
}//namespace glm

230
glm/detail/type_vec3.inl
View File

@ -6,39 +6,39 @@ namespace glm
// -- Implicit basic constructors --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec()
{}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(vec<3, T, P> const & v)
: x(v.x), y(v.y), z(v.z)
{}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<precision Q>
template<typename T, qualifier P>
template<qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(vec<3, T, Q> const & v)
: x(v.x), y(v.y), z(v.z)
{}
// -- Explicit basic constructors --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(T scalar)
: x(scalar), y(scalar), z(scalar)
{}
template <typename T, precision P>
template <typename T, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(T _x, T _y, T _z)
: x(_x), y(_y), z(_z)
{}
// -- Conversion scalar constructors --
template<typename T, precision P>
template<typename T, qualifier P>
template<typename X, typename Y, typename Z>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(X _x, Y _y, Z _z)
: x(static_cast<T>(_x))
@ -46,7 +46,7 @@ namespace glm
, z(static_cast<T>(_z))
{}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename X, typename Y, typename Z>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(vec<1, X, P> const& _x, vec<1, Y, P> const& _y, vec<1, Z, P> const& _z)
: x(static_cast<T>(_x))
@ -56,48 +56,48 @@ namespace glm
// -- Conversion vector constructors --
template<typename T, precision P>
template<typename A, typename B, precision Q>
template<typename T, qualifier P>
template<typename A, typename B, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(vec<2, A, Q> const& _xy, B _z)
: x(static_cast<T>(_xy.x))
, y(static_cast<T>(_xy.y))
, z(static_cast<T>(_z))
{}
template<typename T, precision P>
template<typename A, typename B, precision Q>
template<typename T, qualifier P>
template<typename A, typename B, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(vec<2, A, Q> const& _xy, vec<1, B, Q> const& _z)
: x(static_cast<T>(_xy.x))
, y(static_cast<T>(_xy.y))
, z(static_cast<T>(_z.x))
{}
template<typename T, precision P>
template<typename A, typename B, precision Q>
template<typename T, qualifier P>
template<typename A, typename B, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(A _x, vec<2, B, Q> const& _yz)
: x(static_cast<T>(_x))
, y(static_cast<T>(_yz.x))
, z(static_cast<T>(_yz.y))
{}
template<typename T, precision P>
template<typename A, typename B, precision Q>
template<typename T, qualifier P>
template<typename A, typename B, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(vec<1, A, Q> const& _x, vec<2, B, Q> const& _yz)
: x(static_cast<T>(_x.x))
, y(static_cast<T>(_yz.x))
, z(static_cast<T>(_yz.y))
{}
template<typename T, precision P>
template<typename U, precision Q>
template<typename T, qualifier P>
template<typename U, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(vec<3, U, Q> const& v)
: x(static_cast<T>(v.x))
, y(static_cast<T>(v.y))
, z(static_cast<T>(v.z))
{}
template<typename T, precision P>
template<typename U, precision Q>
template<typename T, qualifier P>
template<typename U, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<3, T, P>::vec(vec<4, U, Q> const& v) :
x(static_cast<T>(v.x)),
y(static_cast<T>(v.y)),
@ -106,14 +106,14 @@ namespace glm
// -- Component accesses --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T & vec<3, T, P>::operator[](typename vec<3, T, P>::length_type i)
{
assert(i >= 0 && i < this->length());
return (&x)[i];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T const & vec<3, T, P>::operator[](typename vec<3, T, P>::length_type i) const
{
assert(i >= 0 && i < this->length());
@ -123,7 +123,7 @@ namespace glm
// -- Unary arithmetic operators --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P>& vec<3, T, P>::operator=(vec<3, T, P> const & v)
{
this->x = v.x;
@ -133,7 +133,7 @@ namespace glm
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P>& vec<3, T, P>::operator=(vec<3, U, P> const & v)
{
@ -143,7 +143,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator+=(U scalar)
{
@ -153,7 +153,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator+=(vec<1, U, P> const & v)
{
@ -163,7 +163,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator+=(vec<3, U, P> const & v)
{
@ -173,7 +173,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator-=(U scalar)
{
@ -183,7 +183,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator-=(vec<1, U, P> const & v)
{
@ -193,7 +193,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator-=(vec<3, U, P> const & v)
{
@ -203,7 +203,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator*=(U scalar)
{
@ -213,7 +213,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator*=(vec<1, U, P> const & v)
{
@ -223,7 +223,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator*=(vec<3, U, P> const & v)
{
@ -233,7 +233,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator/=(U v)
{
@ -243,7 +243,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator/=(vec<1, U, P> const & v)
{
@ -253,7 +253,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator/=(vec<3, U, P> const & v)
{
@ -265,7 +265,7 @@ namespace glm
// -- Increment and decrement operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator++()
{
++this->x;
@ -274,7 +274,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator--()
{
--this->x;
@ -283,7 +283,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> vec<3, T, P>::operator++(int)
{
vec<3, T, P> Result(*this);
@ -291,7 +291,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> vec<3, T, P>::operator--(int)
{
vec<3, T, P> Result(*this);
@ -301,7 +301,7 @@ namespace glm
// -- Unary bit operators --
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator%=(U scalar)
{
@ -311,7 +311,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator%=(vec<1, U, P> const & v)
{
@ -321,7 +321,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator%=(vec<3, U, P> const & v)
{
@ -331,7 +331,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator&=(U scalar)
{
@ -341,7 +341,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator&=(vec<1, U, P> const & v)
{
@ -351,7 +351,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator&=(vec<3, U, P> const & v)
{
@ -361,7 +361,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator|=(U scalar)
{
@ -371,7 +371,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator|=(vec<1, U, P> const & v)
{
@ -381,7 +381,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator|=(vec<3, U, P> const & v)
{
@ -391,7 +391,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator^=(U scalar)
{
@ -401,7 +401,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator^=(vec<1, U, P> const & v)
{
@ -411,7 +411,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator^=(vec<3, U, P> const & v)
{
@ -421,7 +421,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator<<=(U scalar)
{
@ -431,7 +431,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator<<=(vec<1, U, P> const & v)
{
@ -441,7 +441,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator<<=(vec<3, U, P> const & v)
{
@ -451,7 +451,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator>>=(U scalar)
{
@ -461,7 +461,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator>>=(vec<1, U, P> const & v)
{
@ -471,7 +471,7 @@ namespace glm
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<3, T, P> & vec<3, T, P>::operator>>=(vec<3, U, P> const & v)
{
@ -483,13 +483,13 @@ namespace glm
// -- Unary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator+(vec<3, T, P> const & v)
{
return v;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator-(vec<3, T, P> const & v)
{
return vec<3, T, P>(
@ -500,7 +500,7 @@ namespace glm
// -- Binary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator+(vec<3, T, P> const & v, T scalar)
{
return vec<3, T, P>(
@ -509,7 +509,7 @@ namespace glm
v.z + scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator+(vec<3, T, P> const & v, vec<1, T, P> const & scalar)
{
return vec<3, T, P>(
@ -518,7 +518,7 @@ namespace glm
v.z + scalar.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator+(T scalar, vec<3, T, P> const & v)
{
return vec<3, T, P>(
@ -527,7 +527,7 @@ namespace glm
scalar + v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator+(vec<1, T, P> const & scalar, vec<3, T, P> const & v)
{
return vec<3, T, P>(
@ -536,7 +536,7 @@ namespace glm
scalar.x + v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator+(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
{
return vec<3, T, P>(
@ -545,7 +545,7 @@ namespace glm
v1.z + v2.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator-(vec<3, T, P> const & v, T scalar)
{
return vec<3, T, P>(
@ -554,7 +554,7 @@ namespace glm
v.z - scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator-(vec<3, T, P> const & v, vec<1, T, P> const & scalar)
{
return vec<3, T, P>(
@ -563,7 +563,7 @@ namespace glm
v.z - scalar.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator-(T scalar, vec<3, T, P> const & v)
{
return vec<3, T, P>(
@ -572,7 +572,7 @@ namespace glm
scalar - v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator-(vec<1, T, P> const & scalar, vec<3, T, P> const & v)
{
return vec<3, T, P>(
@ -581,7 +581,7 @@ namespace glm
scalar.x - v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator-(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
{
return vec<3, T, P>(
@ -590,7 +590,7 @@ namespace glm
v1.z - v2.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator*(vec<3, T, P> const & v, T scalar)
{
return vec<3, T, P>(
@ -599,7 +599,7 @@ namespace glm
v.z * scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator*(vec<3, T, P> const & v, vec<1, T, P> const & scalar)
{
return vec<3, T, P>(
@ -608,7 +608,7 @@ namespace glm
v.z * scalar.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator*(T scalar, vec<3, T, P> const & v)
{
return vec<3, T, P>(
@ -617,7 +617,7 @@ namespace glm
scalar * v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator*(vec<1, T, P> const & scalar, vec<3, T, P> const & v)
{
return vec<3, T, P>(
@ -626,7 +626,7 @@ namespace glm
scalar.x * v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator*(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
{
return vec<3, T, P>(
@ -635,7 +635,7 @@ namespace glm
v1.z * v2.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator/(vec<3, T, P> const & v, T scalar)
{
return vec<3, T, P>(
@ -644,7 +644,7 @@ namespace glm
v.z / scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator/(vec<3, T, P> const & v, vec<1, T, P> const & scalar)
{
return vec<3, T, P>(
@ -653,7 +653,7 @@ namespace glm
v.z / scalar.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator/(T scalar, vec<3, T, P> const & v)
{
return vec<3, T, P>(
@ -662,7 +662,7 @@ namespace glm
scalar / v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator/(vec<1, T, P> const & scalar, vec<3, T, P> const & v)
{
return vec<3, T, P>(
@ -671,7 +671,7 @@ namespace glm
scalar.x / v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator/(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
{
return vec<3, T, P>(
@ -682,7 +682,7 @@ namespace glm
// -- Binary bit operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator%(vec<3, T, P> const & v, T scalar)
{
return vec<3, T, P>(
@ -691,7 +691,7 @@ namespace glm
v.z % scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator%(vec<3, T, P> const & v, vec<1, T, P> const & scalar)
{
return vec<3, T, P>(
@ -700,7 +700,7 @@ namespace glm
v.z % scalar.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator%(T scalar, vec<3, T, P> const & v)
{
return vec<3, T, P>(
@ -709,7 +709,7 @@ namespace glm
scalar % v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator%(vec<1, T, P> const & scalar, vec<3, T, P> const & v)
{
return vec<3, T, P>(
@ -718,7 +718,7 @@ namespace glm
scalar.x % v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator%(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
{
return vec<3, T, P>(
@ -727,7 +727,7 @@ namespace glm
v1.z % v2.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator&(vec<3, T, P> const & v, T scalar)
{
return vec<3, T, P>(
@ -736,7 +736,7 @@ namespace glm
v.z & scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator&(vec<3, T, P> const & v, vec<1, T, P> const & scalar)
{
return vec<3, T, P>(
@ -745,7 +745,7 @@ namespace glm
v.z & scalar.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator&(T scalar, vec<3, T, P> const & v)
{
return vec<3, T, P>(
@ -754,7 +754,7 @@ namespace glm
scalar & v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator&(vec<1, T, P> const & scalar, vec<3, T, P> const & v)
{
return vec<3, T, P>(
@ -763,7 +763,7 @@ namespace glm
scalar.x & v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator&(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
{
return vec<3, T, P>(
@ -772,7 +772,7 @@ namespace glm
v1.z & v2.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator|(vec<3, T, P> const & v, T scalar)
{
return vec<3, T, P>(
@ -781,7 +781,7 @@ namespace glm
v.z | scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator|(vec<3, T, P> const & v, vec<1, T, P> const & scalar)
{
return vec<3, T, P>(
@ -790,7 +790,7 @@ namespace glm
v.z | scalar.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator|(T scalar, vec<3, T, P> const & v)
{
return vec<3, T, P>(
@ -799,7 +799,7 @@ namespace glm
scalar | v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator|(vec<1, T, P> const & scalar, vec<3, T, P> const & v)
{
return vec<3, T, P>(
@ -808,7 +808,7 @@ namespace glm
scalar.x | v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator|(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
{
return vec<3, T, P>(
@ -817,7 +817,7 @@ namespace glm
v1.z | v2.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator^(vec<3, T, P> const & v, T scalar)
{
return vec<3, T, P>(
@ -826,7 +826,7 @@ namespace glm
v.z ^ scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator^(vec<3, T, P> const & v, vec<1, T, P> const & scalar)
{
return vec<3, T, P>(
@ -835,7 +835,7 @@ namespace glm
v.z ^ scalar.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator^(T scalar, vec<3, T, P> const & v)
{
return vec<3, T, P>(
@ -844,7 +844,7 @@ namespace glm
scalar ^ v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator^(vec<1, T, P> const & scalar, vec<3, T, P> const & v)
{
return vec<3, T, P>(
@ -853,7 +853,7 @@ namespace glm
scalar.x ^ v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator^(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
{
return vec<3, T, P>(
@ -862,7 +862,7 @@ namespace glm
v1.z ^ v2.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator<<(vec<3, T, P> const & v, T scalar)
{
return vec<3, T, P>(
@ -871,7 +871,7 @@ namespace glm
v.z << scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator<<(vec<3, T, P> const & v, vec<1, T, P> const & scalar)
{
return vec<3, T, P>(
@ -880,7 +880,7 @@ namespace glm
v.z << scalar.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator<<(T scalar, vec<3, T, P> const & v)
{
return vec<3, T, P>(
@ -889,7 +889,7 @@ namespace glm
scalar << v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator<<(vec<1, T, P> const & scalar, vec<3, T, P> const & v)
{
return vec<3, T, P>(
@ -898,7 +898,7 @@ namespace glm
scalar.x << v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator<<(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
{
return vec<3, T, P>(
@ -907,7 +907,7 @@ namespace glm
v1.z << v2.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator>>(vec<3, T, P> const & v, T scalar)
{
return vec<3, T, P>(
@ -916,7 +916,7 @@ namespace glm
v.z >> scalar);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator>>(vec<3, T, P> const & v, vec<1, T, P> const & scalar)
{
return vec<3, T, P>(
@ -925,7 +925,7 @@ namespace glm
v.z >> scalar.x);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator>>(T scalar, vec<3, T, P> const & v)
{
return vec<3, T, P>(
@ -934,7 +934,7 @@ namespace glm
scalar >> v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator>>(vec<1, T, P> const & scalar, vec<3, T, P> const & v)
{
return vec<3, T, P>(
@ -943,7 +943,7 @@ namespace glm
scalar.x >> v.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator>>(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
{
return vec<3, T, P>(
@ -952,7 +952,7 @@ namespace glm
v1.z >> v2.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator~(vec<3, T, P> const & v)
{
return vec<3, T, P>(
@ -963,7 +963,7 @@ namespace glm
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator==(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
{
return
@ -972,19 +972,19 @@ namespace glm
detail::compute_equal<T>::call(v1.z, v2.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator!=(vec<3, T, P> const & v1, vec<3, T, P> const & v2)
{
return !(v1 == v2);
}
template<precision P>
template<qualifier P>
GLM_FUNC_QUALIFIER vec<3, bool, P> operator&&(vec<3, bool, P> const & v1, vec<3, bool, P> const & v2)
{
return vec<3, bool, P>(v1.x && v2.x, v1.y && v2.y, v1.z && v2.z);
}
template<precision P>
template<qualifier P>
GLM_FUNC_QUALIFIER vec<3, bool, P> operator||(vec<3, bool, P> const & v1, vec<3, bool, P> const & v2)
{
return vec<3, bool, P>(v1.x || v2.x, v1.y || v2.y, v1.z || v2.z);

142
glm/detail/type_vec4.hpp
View File

@ -15,7 +15,7 @@
namespace glm
{
template<typename T, precision P>
template<typename T, qualifier P>
struct vec<4, T, P>
{
// -- Implementation detail --
@ -91,7 +91,7 @@ namespace glm
GLM_FUNC_DECL GLM_CONSTEXPR_SIMD vec() GLM_DEFAULT;
GLM_FUNC_DECL GLM_CONSTEXPR_SIMD vec(vec<4, T, P> const& v) GLM_DEFAULT;
template<precision Q>
template<qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_SIMD vec(vec<4, T, Q> const& v);
// -- Explicit basic constructors --
@ -110,41 +110,41 @@ namespace glm
// -- Conversion vector constructors --
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename A, typename B, typename C, precision Q>
template<typename A, typename B, typename C, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<2, A, Q> const& _xy, B _z, C _w);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename A, typename B, typename C, precision Q>
template<typename A, typename B, typename C, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<2, A, Q> const& _xy, vec<1, B, Q> const& _z, vec<1, C, Q> const& _w);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename A, typename B, typename C, precision Q>
template<typename A, typename B, typename C, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(A _x, vec<2, B, Q> const& _yz, C _w);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename A, typename B, typename C, precision Q>
template<typename A, typename B, typename C, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<1, A, Q> const& _x, vec<2, B, Q> const& _yz, vec<1, C, Q> const& _w);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename A, typename B, typename C, precision Q>
template<typename A, typename B, typename C, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(A _x, B _y, vec<2, C, Q> const& _zw);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename A, typename B, typename C, precision Q>
template<typename A, typename B, typename C, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<1, A, Q> const& _x, vec<1, B, Q> const& _y, vec<2, C, Q> const& _zw);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename A, typename B, precision Q>
template<typename A, typename B, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<3, A, Q> const& _xyz, B _w);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename A, typename B, precision Q>
template<typename A, typename B, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<3, A, Q> const& _xyz, vec<1, B, Q> const& _w);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename A, typename B, precision Q>
template<typename A, typename B, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(A _x, vec<3, B, Q> const& _yzw);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename A, typename B, precision Q>
template<typename A, typename B, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<1, A, Q> const& _x, vec<3, B, Q> const& _yzw);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename A, typename B, precision Q>
template<typename A, typename B, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<2, A, Q> const& _xy, vec<2, B, Q> const& _zw);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template<typename U, precision Q>
template<typename U, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR GLM_EXPLICIT vec(vec<4, U, Q> const& v);
// -- Swizzle constructors --
@ -272,179 +272,179 @@ namespace glm
// -- Unary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator+(vec<4, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator-(vec<4, T, P> const & v);
// -- Binary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator+(vec<4, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator+(vec<4, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator+(T scalar, vec<4, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator+(vec<1, T, P> const & v1, vec<4, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator+(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator-(vec<4, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator-(vec<4, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator-(T scalar, vec<4, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator-(vec<1, T, P> const & v1, vec<4, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator-(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator*(vec<4, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator*(vec<4, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator*(T scalar, vec<4, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator*(vec<1, T, P> const & v1, vec<4, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator*(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator/(vec<4, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator/(vec<4, T, P> const & v1, vec<1, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator/(T scalar, vec<4, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator/(vec<1, T, P> const & v1, vec<4, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator/(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator%(vec<4, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator%(vec<4, T, P> const & v, vec<1, T, P> const & scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator%(T scalar, vec<4, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator%(vec<1, T, P> const & scalar, vec<4, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator%(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator&(vec<4, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator&(vec<4, T, P> const & v, vec<1, T, P> const & scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator&(T scalar, vec<4, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator&(vec<1, T, P> const & scalar, vec<4, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator&(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator|(vec<4, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator|(vec<4, T, P> const & v, vec<1, T, P> const & scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator|(T scalar, vec<4, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator|(vec<1, T, P> const & scalar, vec<4, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator|(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator^(vec<4, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator^(vec<4, T, P> const & v, vec<1, T, P> const & scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator^(T scalar, vec<4, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator^(vec<1, T, P> const & scalar, vec<4, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator^(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator<<(vec<4, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator<<(vec<4, T, P> const & v, vec<1, T, P> const & scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator<<(T scalar, vec<4, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator<<(vec<1, T, P> const & scalar, vec<4, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator<<(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator>>(vec<4, T, P> const & v, T scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator>>(vec<4, T, P> const & v, vec<1, T, P> const & scalar);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator>>(T scalar, vec<4, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator>>(vec<1, T, P> const & scalar, vec<4, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator>>(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator~(vec<4, T, P> const & v);
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator==(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator!=(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
template<precision P>
template<qualifier P>
GLM_FUNC_DECL vec<4, bool, P> operator&&(vec<4, bool, P> const & v1, vec<4, bool, P> const & v2);
template<precision P>
template<qualifier P>
GLM_FUNC_DECL vec<4, bool, P> operator||(vec<4, bool, P> const & v1, vec<4, bool, P> const & v2);
}//namespace glm

280
glm/detail/type_vec4.inl
View File

@ -34,7 +34,7 @@ namespace detail
enum test {value = ~0};
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_vec4_add
{
GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b)
@ -43,7 +43,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_vec4_sub
{
GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b)
@ -52,7 +52,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_vec4_mul
{
GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b)
@ -61,7 +61,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_vec4_div
{
GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b)
@ -70,7 +70,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_vec4_mod
{
GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b)
@ -79,7 +79,7 @@ namespace detail
}
};
template<typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
template<typename T, qualifier P, int IsInt, std::size_t Size, bool Aligned>
struct compute_vec4_and
{
GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b)
@ -88,7 +88,7 @@ namespace detail
}
};
template<typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
template<typename T, qualifier P, int IsInt, std::size_t Size, bool Aligned>
struct compute_vec4_or
{
GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b)
@ -97,7 +97,7 @@ namespace detail
}
};
template<typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
template<typename T, qualifier P, int IsInt, std::size_t Size, bool Aligned>
struct compute_vec4_xor
{
GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b)
@ -106,7 +106,7 @@ namespace detail
}
};
template<typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
template<typename T, qualifier P, int IsInt, std::size_t Size, bool Aligned>
struct compute_vec4_shift_left
{
GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b)
@ -115,7 +115,7 @@ namespace detail
}
};
template<typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
template<typename T, qualifier P, int IsInt, std::size_t Size, bool Aligned>
struct compute_vec4_shift_right
{
GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & a, vec<4, T, P> const & b)
@ -124,7 +124,7 @@ namespace detail
}
};
template<typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
template<typename T, qualifier P, int IsInt, std::size_t Size, bool Aligned>
struct compute_vec4_equal
{
GLM_FUNC_QUALIFIER static bool call(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
@ -137,7 +137,7 @@ namespace detail
}
};
template<typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
template<typename T, qualifier P, int IsInt, std::size_t Size, bool Aligned>
struct compute_vec4_nequal
{
GLM_FUNC_QUALIFIER static bool call(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
@ -146,7 +146,7 @@ namespace detail
}
};
template<typename T, precision P, int IsInt, std::size_t Size, bool Aligned>
template<typename T, qualifier P, int IsInt, std::size_t Size, bool Aligned>
struct compute_vec4_bitwise_not
{
GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const & v)
@ -159,39 +159,39 @@ namespace detail
// -- Implicit basic constructors --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, P>::vec()
{}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, P>::vec(vec<4, T, P> const & v)
: x(v.x), y(v.y), z(v.z), w(v.w)
{}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<precision Q>
template<typename T, qualifier P>
template<qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, P>::vec(vec<4, T, Q> const & v)
: x(v.x), y(v.y), z(v.z), w(v.w)
{}
// -- Explicit basic constructors --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, P>::vec(T scalar)
: x(scalar), y(scalar), z(scalar), w(scalar)
{}
template <typename T, precision P>
template <typename T, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, P>::vec(T _x, T _y, T _z, T _w)
: x(_x), y(_y), z(_z), w(_w)
{}
// -- Conversion scalar constructors --
template<typename T, precision P>
template<typename T, qualifier P>
template<typename X, typename Y, typename Z, typename W>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD vec<4, T, P>::vec(X _x, Y _y, Z _z, W _w)
: x(static_cast<T>(_x))
@ -200,7 +200,7 @@ namespace detail
, w(static_cast<T>(_w))
{}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename X, typename Y, typename Z, typename W>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(vec<1, X, P> const& _x, vec<1, Y, P> const& _y, vec<1, Z, P> const& _z, vec<1, W, P> const& _w)
: x(static_cast<T>(_x.x))
@ -211,8 +211,8 @@ namespace detail
// -- Conversion vector constructors --
template<typename T, precision P>
template<typename A, typename B, typename C, precision Q>
template<typename T, qualifier P>
template<typename A, typename B, typename C, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(vec<2, A, Q> const& _xy, B _z, C _w)
: x(static_cast<T>(_xy.x))
, y(static_cast<T>(_xy.y))
@ -220,8 +220,8 @@ namespace detail
, w(static_cast<T>(_w))
{}
template<typename T, precision P>
template<typename A, typename B, typename C, precision Q>
template<typename T, qualifier P>
template<typename A, typename B, typename C, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(vec<2, A, Q> const& _xy, vec<1, B, Q> const& _z, vec<1, C, Q> const& _w)
: x(static_cast<T>(_xy.x))
, y(static_cast<T>(_xy.y))
@ -229,8 +229,8 @@ namespace detail
, w(static_cast<T>(_w.x))
{}
template<typename T, precision P>
template<typename A, typename B, typename C, precision Q>
template<typename T, qualifier P>
template<typename A, typename B, typename C, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(A _x, vec<2, B, Q> const& _yz, C _w)
: x(static_cast<T>(_x))
, y(static_cast<T>(_yz.x))
@ -238,8 +238,8 @@ namespace detail
, w(static_cast<T>(_w))
{}
template<typename T, precision P>
template<typename A, typename B, typename C, precision Q>
template<typename T, qualifier P>
template<typename A, typename B, typename C, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(vec<1, A, Q> const& _x, vec<2, B, Q> const& _yz, vec<1, C, Q> const& _w)
: x(static_cast<T>(_x.x))
, y(static_cast<T>(_yz.x))
@ -247,8 +247,8 @@ namespace detail
, w(static_cast<T>(_w.x))
{}
template<typename T, precision P>
template<typename A, typename B, typename C, precision Q>
template<typename T, qualifier P>
template<typename A, typename B, typename C, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(A _x, B _y, vec<2, C, Q> const& _zw)
: x(static_cast<T>(_x))
, y(static_cast<T>(_y))
@ -256,8 +256,8 @@ namespace detail
, w(static_cast<T>(_zw.y))
{}
template<typename T, precision P>
template<typename A, typename B, typename C, precision Q>
template<typename T, qualifier P>
template<typename A, typename B, typename C, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(vec<1, A, Q> const& _x, vec<1, B, Q> const& _y, vec<2, C, Q> const& _zw)
: x(static_cast<T>(_x.x))
, y(static_cast<T>(_y.x))
@ -265,8 +265,8 @@ namespace detail
, w(static_cast<T>(_zw.y))
{}
template<typename T, precision P>
template<typename A, typename B, precision Q>
template<typename T, qualifier P>
template<typename A, typename B, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(vec<3, A, Q> const& _xyz, B _w) :
x(static_cast<T>(_xyz.x)),
y(static_cast<T>(_xyz.y)),
@ -274,8 +274,8 @@ namespace detail
w(static_cast<T>(_w))
{}
template<typename T, precision P>
template<typename A, typename B, precision Q>
template<typename T, qualifier P>
template<typename A, typename B, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(vec<3, A, Q> const& _xyz, vec<1, B, Q> const& _w) :
x(static_cast<T>(_xyz.x)),
y(static_cast<T>(_xyz.y)),
@ -283,8 +283,8 @@ namespace detail
w(static_cast<T>(_w.x))
{}
template<typename T, precision P>
template<typename A, typename B, precision Q>
template<typename T, qualifier P>
template<typename A, typename B, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(A _x, vec<3, B, Q> const& _yzw) :
x(static_cast<T>(_x)),
y(static_cast<T>(_yzw.x)),
@ -292,8 +292,8 @@ namespace detail
w(static_cast<T>(_yzw.z))
{}
template<typename T, precision P>
template<typename A, typename B, precision Q>
template<typename T, qualifier P>
template<typename A, typename B, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(vec<1, A, Q> const& _x, vec<3, B, Q> const& _yzw) :
x(static_cast<T>(_x.x)),
y(static_cast<T>(_yzw.x)),
@ -301,8 +301,8 @@ namespace detail
w(static_cast<T>(_yzw.z))
{}
template<typename T, precision P>
template<typename A, typename B, precision Q>
template<typename T, qualifier P>
template<typename A, typename B, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(vec<2, A, Q> const& _xy, vec<2, B, Q> const& _zw) :
x(static_cast<T>(_xy.x)),
y(static_cast<T>(_xy.y)),
@ -310,8 +310,8 @@ namespace detail
w(static_cast<T>(_zw.y))
{}
template<typename T, precision P>
template<typename U, precision Q>
template<typename T, qualifier P>
template<typename U, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<4, T, P>::vec(vec<4, U, Q> const& v) :
x(static_cast<T>(v.x)),
y(static_cast<T>(v.y)),
@ -321,14 +321,14 @@ namespace detail
// -- Component accesses --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T& vec<4, T, P>::operator[](typename vec<4, T, P>::length_type i)
{
assert(i >= 0 && i < this->length());
return (&x)[i];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T const& vec<4, T, P>::operator[](typename vec<4, T, P>::length_type i) const
{
assert(i >= 0 && i < this->length());
@ -338,7 +338,7 @@ namespace detail
// -- Unary arithmetic operators --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P>& vec<4, T, P>::operator=(vec<4, T, P> const & v)
{
this->x = v.x;
@ -349,7 +349,7 @@ namespace detail
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P>& vec<4, T, P>::operator=(vec<4, U, P> const & v)
{
@ -360,84 +360,84 @@ namespace detail
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator+=(U scalar)
{
return (*this = detail::compute_vec4_add<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(scalar)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator+=(vec<1, U, P> const & v)
{
return (*this = detail::compute_vec4_add<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v.x)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator+=(vec<4, U, P> const & v)
{
return (*this = detail::compute_vec4_add<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator-=(U scalar)
{
return (*this = detail::compute_vec4_sub<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(scalar)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator-=(vec<1, U, P> const & v)
{
return (*this = detail::compute_vec4_sub<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v.x)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator-=(vec<4, U, P> const & v)
{
return (*this = detail::compute_vec4_sub<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator*=(U scalar)
{
return (*this = detail::compute_vec4_mul<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(scalar)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator*=(vec<1, U, P> const & v)
{
return (*this = detail::compute_vec4_mul<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v.x)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator*=(vec<4, U, P> const & v)
{
return (*this = detail::compute_vec4_mul<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator/=(U scalar)
{
return (*this = detail::compute_vec4_div<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(scalar)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator/=(vec<1, U, P> const & v)
{
return (*this = detail::compute_vec4_div<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v.x)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator/=(vec<4, U, P> const & v)
{
@ -446,7 +446,7 @@ namespace detail
// -- Increment and decrement operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator++()
{
++this->x;
@ -456,7 +456,7 @@ namespace detail
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator--()
{
--this->x;
@ -466,7 +466,7 @@ namespace detail
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> vec<4, T, P>::operator++(int)
{
vec<4, T, P> Result(*this);
@ -474,7 +474,7 @@ namespace detail
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> vec<4, T, P>::operator--(int)
{
vec<4, T, P> Result(*this);
@ -484,126 +484,126 @@ namespace detail
// -- Unary bit operators --
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator%=(U scalar)
{
return (*this = detail::compute_vec4_mod<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(scalar)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator%=(vec<1, U, P> const& v)
{
return (*this = detail::compute_vec4_mod<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator%=(vec<4, U, P> const& v)
{
return (*this = detail::compute_vec4_mod<T, P, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator&=(U scalar)
{
return (*this = detail::compute_vec4_and<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(scalar)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator&=(vec<1, U, P> const & v)
{
return (*this = detail::compute_vec4_and<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator&=(vec<4, U, P> const & v)
{
return (*this = detail::compute_vec4_and<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator|=(U scalar)
{
return (*this = detail::compute_vec4_or<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(scalar)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator|=(vec<1, U, P> const & v)
{
return (*this = detail::compute_vec4_or<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator|=(vec<4, U, P> const & v)
{
return (*this = detail::compute_vec4_or<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator^=(U scalar)
{
return (*this = detail::compute_vec4_xor<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(scalar)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator^=(vec<1, U, P> const & v)
{
return (*this = detail::compute_vec4_xor<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator^=(vec<4, U, P> const & v)
{
return (*this = detail::compute_vec4_xor<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator<<=(U scalar)
{
return (*this = detail::compute_vec4_shift_left<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(scalar)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator<<=(vec<1, U, P> const & v)
{
return (*this = detail::compute_vec4_shift_left<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator<<=(vec<4, U, P> const & v)
{
return (*this = detail::compute_vec4_shift_left<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator>>=(U scalar)
{
return (*this = detail::compute_vec4_shift_right<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(scalar)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator>>=(vec<1, U, P> const & v)
{
return (*this = detail::compute_vec4_shift_right<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(*this, vec<4, T, P>(v)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER vec<4, T, P> & vec<4, T, P>::operator>>=(vec<4, U, P> const & v)
{
@ -612,13 +612,13 @@ namespace detail
// -- Unary constant operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator+(vec<4, T, P> const & v)
{
return v;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator-(vec<4, T, P> const & v)
{
return vec<4, T, P>(0) -= v;
@ -626,121 +626,121 @@ namespace detail
// -- Binary arithmetic operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator+(vec<4, T, P> const & v, T scalar)
{
return vec<4, T, P>(v) += scalar;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator+(vec<4, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<4, T, P>(v1) += v2;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator+(T scalar, vec<4, T, P> const & v)
{
return vec<4, T, P>(v) += scalar;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator+(vec<1, T, P> const & v1, vec<4, T, P> const & v2)
{
return vec<4, T, P>(v2) += v1;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator+(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
{
return vec<4, T, P>(v1) += v2;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator-(vec<4, T, P> const & v, T scalar)
{
return vec<4, T, P>(v) -= scalar;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator-(vec<4, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<4, T, P>(v1) -= v2;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator-(T scalar, vec<4, T, P> const & v)
{
return vec<4, T, P>(scalar) -= v;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator-(vec<1, T, P> const & v1, vec<4, T, P> const & v2)
{
return vec<4, T, P>(v1.x) -= v2;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator-(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
{
return vec<4, T, P>(v1) -= v2;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator*(vec<4, T, P> const & v, T scalar)
{
return vec<4, T, P>(v) *= scalar;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator*(vec<4, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<4, T, P>(v1) *= v2;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator*(T scalar, vec<4, T, P> const & v)
{
return vec<4, T, P>(v) *= scalar;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator*(vec<1, T, P> const & v1, vec<4, T, P> const & v2)
{
return vec<4, T, P>(v2) *= v1;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator*(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
{
return vec<4, T, P>(v1) *= v2;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator/(vec<4, T, P> const & v, T scalar)
{
return vec<4, T, P>(v) /= scalar;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator/(vec<4, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<4, T, P>(v1) /= v2;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator/(T scalar, vec<4, T, P> const & v)
{
return vec<4, T, P>(scalar) /= v;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator/(vec<1, T, P> const & v1, vec<4, T, P> const & v2)
{
return vec<4, T, P>(v1.x) /= v2;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator/(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
{
return vec<4, T, P>(v1) /= v2;
@ -748,187 +748,187 @@ namespace detail
// -- Binary bit operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator%(vec<4, T, P> const & v, T scalar)
{
return vec<4, T, P>(v) %= scalar;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator%(vec<4, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<4, T, P>(v1) %= v2.x;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator%(T scalar, vec<4, T, P> const & v)
{
return vec<4, T, P>(scalar) %= v;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator%(vec<1, T, P> const & scalar, vec<4, T, P> const & v)
{
return vec<4, T, P>(scalar.x) %= v;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator%(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
{
return vec<4, T, P>(v1) %= v2;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator&(vec<4, T, P> const & v, T scalar)
{
return vec<4, T, P>(v) &= scalar;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator&(vec<4, T, P> const & v, vec<1, T, P> const & scalar)
{
return vec<4, T, P>(v) &= scalar;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator&(T scalar, vec<4, T, P> const & v)
{
return vec<4, T, P>(scalar) &= v;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator&(vec<1, T, P> const & v1, vec<4, T, P> const & v2)
{
return vec<4, T, P>(v1.x) &= v2;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator&(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
{
return vec<4, T, P>(v1) &= v2;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator|(vec<4, T, P> const & v, T scalar)
{
return vec<4, T, P>(v) |= scalar;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator|(vec<4, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<4, T, P>(v1) |= v2.x;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator|(T scalar, vec<4, T, P> const & v)
{
return vec<4, T, P>(scalar) |= v;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator|(vec<1, T, P> const & v1, vec<4, T, P> const & v2)
{
return vec<4, T, P>(v1.x) |= v2;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator|(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
{
return vec<4, T, P>(v1) |= v2;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator^(vec<4, T, P> const & v, T scalar)
{
return vec<4, T, P>(v) ^= scalar;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator^(vec<4, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<4, T, P>(v1) ^= v2.x;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator^(T scalar, vec<4, T, P> const & v)
{
return vec<4, T, P>(scalar) ^= v;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator^(vec<1, T, P> const & v1, vec<4, T, P> const & v2)
{
return vec<4, T, P>(v1.x) ^= v2;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator^(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
{
return vec<4, T, P>(v1) ^= v2;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator<<(vec<4, T, P> const & v, T scalar)
{
return vec<4, T, P>(v) <<= scalar;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator<<(vec<4, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<4, T, P>(v1) <<= v2.x;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator<<(T scalar, vec<4, T, P> const & v)
{
return vec<4, T, P>(scalar) <<= v;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator<<(vec<1, T, P> const & v1, vec<4, T, P> const & v2)
{
return vec<4, T, P>(v1.x) <<= v2;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator<<(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
{
return vec<4, T, P>(v1) <<= v2;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator>>(vec<4, T, P> const & v, T scalar)
{
return vec<4, T, P>(v) >>= scalar;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator>>(vec<4, T, P> const & v1, vec<1, T, P> const & v2)
{
return vec<4, T, P>(v1) >>= v2.x;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator>>(T scalar, vec<4, T, P> const & v)
{
return vec<4, T, P>(scalar) >>= v;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator>>(vec<1, T, P> const & v1, vec<4, T, P> const & v2)
{
return vec<4, T, P>(v1.x) >>= v2;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator>>(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
{
return vec<4, T, P>(v1) >>= v2;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator~(vec<4, T, P> const & v)
{
return detail::compute_vec4_bitwise_not<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(v);
@ -936,25 +936,25 @@ namespace detail
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator==(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
{
return detail::compute_vec4_equal<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(v1, v2);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator!=(vec<4, T, P> const & v1, vec<4, T, P> const & v2)
{
return detail::compute_vec4_nequal<T, P, detail::is_int<T>::value, sizeof(T) * 8, detail::is_aligned<P>::value>::call(v1, v2);
}
template<precision P>
template<qualifier P>
GLM_FUNC_QUALIFIER vec<4, bool, P> operator&&(vec<4, bool, P> const & v1, vec<4, bool, P> const & v2)
{
return vec<4, bool, P>(v1.x && v2.x, v1.y && v2.y, v1.z && v2.z, v1.w && v2.w);
}
template<precision P>
template<qualifier P>
GLM_FUNC_QUALIFIER vec<4, bool, P> operator||(vec<4, bool, P> const & v1, vec<4, bool, P> const & v2)
{
return vec<4, bool, P>(v1.x || v2.x, v1.y || v2.y, v1.z || v2.z, v1.w || v2.w);

54
glm/detail/type_vec4_simd.inl
View File

@ -7,7 +7,7 @@ namespace glm{
namespace detail
{
# if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
template<precision P, int E0, int E1, int E2, int E3>
template<qualifier P, int E0, int E1, int E2, int E3>
struct _swizzle_base1<4, float, P, E0,E1,E2,E3, true> : public _swizzle_base0<float, 4>
{
GLM_FUNC_QUALIFIER vec<4, float, P> operator ()() const
@ -24,7 +24,7 @@ namespace detail
}
};
template<precision P, int E0, int E1, int E2, int E3>
template<qualifier P, int E0, int E1, int E2, int E3>
struct _swizzle_base1<4, int32, P, E0,E1,E2,E3, true> : public _swizzle_base0<int32, 4>
{
GLM_FUNC_QUALIFIER vec<4, int32, P> operator ()() const
@ -37,7 +37,7 @@ namespace detail
}
};
template<precision P, int E0, int E1, int E2, int E3>
template<qualifier P, int E0, int E1, int E2, int E3>
struct _swizzle_base1<4, uint32, P, E0,E1,E2,E3, true> : public _swizzle_base0<uint32, 4>
{
GLM_FUNC_QUALIFIER vec<4, uint32, P> operator ()() const
@ -51,7 +51,7 @@ namespace detail
};
# endif// GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
template<precision P>
template<qualifier P>
struct compute_vec4_add<float, P, true>
{
static vec<4, float, P> call(vec<4, float, P> const & a, vec<4, float, P> const & b)
@ -63,7 +63,7 @@ namespace detail
};
# if GLM_ARCH & GLM_ARCH_AVX_BIT
template<precision P>
template<qualifier P>
struct compute_vec4_add<double, P, true>
{
static vec<4, double, P> call(vec<4, double, P> const & a, vec<4, double, P> const & b)
@ -75,7 +75,7 @@ namespace detail
};
# endif
template<precision P>
template<qualifier P>
struct compute_vec4_sub<float, P, true>
{
static vec<4, float, P> call(vec<4, float, P> const & a, vec<4, float, P> const & b)
@ -87,7 +87,7 @@ namespace detail
};
# if GLM_ARCH & GLM_ARCH_AVX_BIT
template<precision P>
template<qualifier P>
struct compute_vec4_sub<double, P, true>
{
static vec<4, double, P> call(vec<4, double, P> const & a, vec<4, double, P> const & b)
@ -99,7 +99,7 @@ namespace detail
};
# endif
template<precision P>
template<qualifier P>
struct compute_vec4_mul<float, P, true>
{
static vec<4, float, P> call(vec<4, float, P> const & a, vec<4, float, P> const & b)
@ -111,7 +111,7 @@ namespace detail
};
# if GLM_ARCH & GLM_ARCH_AVX_BIT
template<precision P>
template<qualifier P>
struct compute_vec4_mul<double, P, true>
{
static vec<4, double, P> call(vec<4, double, P> const & a, vec<4, double, P> const & b)
@ -123,7 +123,7 @@ namespace detail
};
# endif
template<precision P>
template<qualifier P>
struct compute_vec4_div<float, P, true>
{
static vec<4, float, P> call(vec<4, float, P> const & a, vec<4, float, P> const & b)
@ -135,7 +135,7 @@ namespace detail
};
# if GLM_ARCH & GLM_ARCH_AVX_BIT
template<precision P>
template<qualifier P>
struct compute_vec4_div<double, P, true>
{
static vec<4, double, P> call(vec<4, double, P> const & a, vec<4, double, P> const & b)
@ -158,7 +158,7 @@ namespace detail
}
};
template<typename T, precision P>
template<typename T, qualifier P>
struct compute_vec4_and<T, P, true, 32, true>
{
static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b)
@ -170,7 +170,7 @@ namespace detail
};
# if GLM_ARCH & GLM_ARCH_AVX2_BIT
template<typename T, precision P>
template<typename T, qualifier P>
struct compute_vec4_and<T, P, true, 64, true>
{
static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b)
@ -182,7 +182,7 @@ namespace detail
};
# endif
template<typename T, precision P>
template<typename T, qualifier P>
struct compute_vec4_or<T, P, true, 32, true>
{
static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b)
@ -194,7 +194,7 @@ namespace detail
};
# if GLM_ARCH & GLM_ARCH_AVX2_BIT
template<typename T, precision P>
template<typename T, qualifier P>
struct compute_vec4_or<T, P, true, 64, true>
{
static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b)
@ -206,7 +206,7 @@ namespace detail
};
# endif
template<typename T, precision P>
template<typename T, qualifier P>
struct compute_vec4_xor<T, P, true, 32, true>
{
static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b)
@ -218,7 +218,7 @@ namespace detail
};
# if GLM_ARCH & GLM_ARCH_AVX2_BIT
template<typename T, precision P>
template<typename T, qualifier P>
struct compute_vec4_xor<T, P, true, 64, true>
{
static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b)
@ -230,7 +230,7 @@ namespace detail
};
# endif
template<typename T, precision P>
template<typename T, qualifier P>
struct compute_vec4_shift_left<T, P, true, 32, true>
{
static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b)
@ -242,7 +242,7 @@ namespace detail
};
# if GLM_ARCH & GLM_ARCH_AVX2_BIT
template<typename T, precision P>
template<typename T, qualifier P>
struct compute_vec4_shift_left<T, P, true, 64, true>
{
static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b)
@ -254,7 +254,7 @@ namespace detail
};
# endif
template<typename T, precision P>
template<typename T, qualifier P>
struct compute_vec4_shift_right<T, P, true, 32, true>
{
static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b)
@ -266,7 +266,7 @@ namespace detail
};
# if GLM_ARCH & GLM_ARCH_AVX2_BIT
template<typename T, precision P>
template<typename T, qualifier P>
struct compute_vec4_shift_right<T, P, true, 64, true>
{
static vec<4, T, P> call(vec<4, T, P> const& a, vec<4, T, P> const& b)
@ -278,7 +278,7 @@ namespace detail
};
# endif
template<typename T, precision P>
template<typename T, qualifier P>
struct compute_vec4_bitwise_not<T, P, true, 32, true>
{
static vec<4, T, P> call(vec<4, T, P> const & v)
@ -290,7 +290,7 @@ namespace detail
};
# if GLM_ARCH & GLM_ARCH_AVX2_BIT
template<typename T, precision P>
template<typename T, qualifier P>
struct compute_vec4_bitwise_not<T, P, true, 64, true>
{
static vec<4, T, P> call(vec<4, T, P> const & v)
@ -302,7 +302,7 @@ namespace detail
};
# endif
template<precision P>
template<qualifier P>
struct compute_vec4_equal<float, P, false, 32, true>
{
static bool call(vec<4, float, P> const & v1, vec<4, float, P> const & v2)
@ -311,7 +311,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_vec4_equal<int32, P, true, 32, true>
{
static bool call(vec<4, int32, P> const & v1, vec<4, int32, P> const & v2)
@ -320,7 +320,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_vec4_nequal<float, P, false, 32, true>
{
static bool call(vec<4, float, P> const & v1, vec<4, float, P> const & v2)
@ -329,7 +329,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_vec4_nequal<int32, P, true, 32, true>
{
static bool call(vec<4, int32, P> const & v1, vec<4, int32, P> const & v2)

1046
glm/fwd.hpp
View File

File diff suppressed because it is too large Load Diff

16
glm/glm.hpp
View File

@ -7,7 +7,7 @@
///
/// The GLM core consists of @ref core_types "C++ types that mirror GLSL types" and
/// C++ functions that mirror the GLSL functions. It also includes
/// @ref core_precision "a set of precision-based types" that can be used in the appropriate
/// @ref core_precision "a set of qualifier-based types" that can be used in the appropriate
/// functions. The C++ types are all based on a basic set of @ref core_template "template types".
///
/// The best documentation for GLM Core is the current GLSL specification,
@ -27,16 +27,16 @@
///
/// @defgroup core_precision Precision types
///
/// @brief Non-GLSL types that are used to define precision-based types.
/// @brief Non-GLSL types that are used to define qualifier-based types.
///
/// The GLSL language allows the user to define the precision of a particular variable.
/// In OpenGL's GLSL, these precision qualifiers have no effect; they are there for compatibility
/// with OpenGL ES's precision qualifiers, where they @em do have an effect.
/// The GLSL language allows the user to define the qualifier of a particular variable.
/// In OpenGL's GLSL, these qualifier qualifiers have no effect; they are there for compatibility
/// with OpenGL ES's qualifier qualifiers, where they @em do have an effect.
///
/// C++ has no language equivalent to precision qualifiers. So GLM provides the next-best thing:
/// a number of typedefs of the @ref core_template that use a particular precision.
/// C++ has no language equivalent to qualifier qualifiers. So GLM provides the next-best thing:
/// a number of typedefs of the @ref core_template that use a particular qualifier.
///
/// None of these types make any guarantees about the actual precision used.
/// None of these types make any guarantees about the actual qualifier used.
///
/// @ingroup core
///

20
glm/gtc/bitfield.hpp
View File

@ -16,7 +16,7 @@
#pragma once
// Dependencies
#include "../detail/precision.hpp"
#include "../detail/qualifier.hpp"
#include "../detail/type_int.hpp"
#include "../detail/_vectorize.hpp"
#include <limits>
@ -39,7 +39,7 @@ namespace glm
/// Build a mask of 'count' bits
///
/// @see gtc_bitfield
template<typename T, precision P, template<typename, precision> class vecIUType>
template<typename T, qualifier P, template<typename, qualifier> class vecIUType>
GLM_FUNC_DECL vecIUType<T, P> mask(vecIUType<T, P> const & v);
/// Rotate all bits to the right. All the bits dropped in the right side are inserted back on the left side.
@ -51,8 +51,8 @@ namespace glm
/// Rotate all bits to the right. All the bits dropped in the right side are inserted back on the left side.
///
/// @see gtc_bitfield
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, T, P> bitfieldRotateRight(vecType<L, T, P> const & In, int Shift);
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> bitfieldRotateRight(vec<L, T, P> const & In, int Shift);
/// Rotate all bits to the left. All the bits dropped in the left side are inserted back on the right side.
///
@ -63,8 +63,8 @@ namespace glm
/// Rotate all bits to the left. All the bits dropped in the left side are inserted back on the right side.
///
/// @see gtc_bitfield
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, T, P> bitfieldRotateLeft(vecType<L, T, P> const & In, int Shift);
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> bitfieldRotateLeft(vec<L, T, P> const & In, int Shift);
/// Set to 1 a range of bits.
///
@ -75,8 +75,8 @@ namespace glm
/// Set to 1 a range of bits.
///
/// @see gtc_bitfield
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, T, P> bitfieldFillOne(vecType<L, T, P> const & Value, int FirstBit, int BitCount);
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> bitfieldFillOne(vec<L, T, P> const & Value, int FirstBit, int BitCount);
/// Set to 0 a range of bits.
///
@ -87,8 +87,8 @@ namespace glm
/// Set to 0 a range of bits.
///
/// @see gtc_bitfield
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, T, P> bitfieldFillZero(vecType<L, T, P> const & Value, int FirstBit, int BitCount);
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> bitfieldFillZero(vec<L, T, P> const & Value, int FirstBit, int BitCount);
/// Interleaves the bits of x and y.
/// The first bit is the first bit of x followed by the first bit of y.

18
glm/gtc/bitfield.inl
View File

@ -230,7 +230,7 @@ namespace detail
return Bits >= sizeof(genIUType) * 8 ? ~static_cast<genIUType>(0) : (static_cast<genIUType>(1) << Bits) - static_cast<genIUType>(1);
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecIUType>
template<length_t L, typename T, qualifier P, template<length_t, typename, qualifier> class vecIUType>
GLM_FUNC_QUALIFIER vecIUType<L, T, P> mask(vecIUType<L, T, P> const& v)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'mask' accepts only integer values");
@ -247,8 +247,8 @@ namespace detail
return (In << static_cast<genIType>(Shift)) | (In >> static_cast<genIType>(BitSize - Shift));
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> bitfieldRotateRight(vecType<L, T, P> const & In, int Shift)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> bitfieldRotateRight(vec<L, T, P> const & In, int Shift)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldRotateRight' accepts only integer values");
@ -265,8 +265,8 @@ namespace detail
return (In >> static_cast<genIType>(Shift)) | (In << static_cast<genIType>(BitSize - Shift));
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> bitfieldRotateLeft(vecType<L, T, P> const& In, int Shift)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> bitfieldRotateLeft(vec<L, T, P> const& In, int Shift)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldRotateLeft' accepts only integer values");
@ -280,8 +280,8 @@ namespace detail
return Value | static_cast<genIUType>(mask(BitCount) << FirstBit);
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> bitfieldFillOne(vecType<L, T, P> const& Value, int FirstBit, int BitCount)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> bitfieldFillOne(vec<L, T, P> const& Value, int FirstBit, int BitCount)
{
return Value | static_cast<T>(mask(BitCount) << FirstBit);
}
@ -292,8 +292,8 @@ namespace detail
return Value & static_cast<genIUType>(~(mask(BitCount) << FirstBit));
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> bitfieldFillZero(vecType<L, T, P> const& Value, int FirstBit, int BitCount)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> bitfieldFillZero(vec<L, T, P> const& Value, int FirstBit, int BitCount)
{
return Value & static_cast<T>(~(mask(BitCount) << FirstBit));
}

18
glm/gtc/color_space.hpp
View File

@ -15,7 +15,7 @@
// Dependencies
#include "../detail/setup.hpp"
#include "../detail/precision.hpp"
#include "../detail/qualifier.hpp"
#include "../exponential.hpp"
#include "../vec3.hpp"
#include "../vec4.hpp"
@ -32,23 +32,23 @@ namespace glm
/// Convert a linear color to sRGB color using a standard gamma correction.
/// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, T, P> convertLinearToSRGB(vecType<L, T, P> const & ColorLinear);
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> convertLinearToSRGB(vec<L, T, P> const & ColorLinear);
/// Convert a linear color to sRGB color using a custom gamma correction.
/// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, T, P> convertLinearToSRGB(vecType<L, T, P> const & ColorLinear, T Gamma);
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> convertLinearToSRGB(vec<L, T, P> const & ColorLinear, T Gamma);
/// Convert a sRGB color to linear color using a standard gamma correction.
/// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, T, P> convertSRGBToLinear(vecType<L, T, P> const & ColorSRGB);
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> convertSRGBToLinear(vec<L, T, P> const & ColorSRGB);
/// Convert a sRGB color to linear color using a custom gamma correction.
// IEC 61966-2-1:1999 / Rec. 709 specification https://www.w3.org/Graphics/Color/srgb
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, T, P> convertSRGBToLinear(vecType<L, T, P> const & ColorSRGB, T Gamma);
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> convertSRGBToLinear(vec<L, T, P> const & ColorSRGB, T Gamma);
/// @}
} //namespace glm

54
glm/gtc/color_space.inl
View File

@ -4,55 +4,55 @@
namespace glm{
namespace detail
{
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
template<length_t L, typename T, qualifier P>
struct compute_rgbToSrgb
{
GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const& ColorRGB, T GammaCorrection)
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& ColorRGB, T GammaCorrection)
{
vecType<L, T, P> const ClampedColor(clamp(ColorRGB, static_cast<T>(0), static_cast<T>(1)));
vec<L, T, P> const ClampedColor(clamp(ColorRGB, static_cast<T>(0), static_cast<T>(1)));
return mix(
pow(ClampedColor, vecType<L, T, P>(GammaCorrection)) * static_cast<T>(1.055) - static_cast<T>(0.055),
pow(ClampedColor, vec<L, T, P>(GammaCorrection)) * static_cast<T>(1.055) - static_cast<T>(0.055),
ClampedColor * static_cast<T>(12.92),
lessThan(ClampedColor, vecType<L, T, P>(static_cast<T>(0.0031308))));
lessThan(ClampedColor, vec<L, T, P>(static_cast<T>(0.0031308))));
}
};
template<typename T, precision P>
struct compute_rgbToSrgb<4, T, P, vec>
template<typename T, qualifier P>
struct compute_rgbToSrgb<4, T, P>
{
GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const& ColorRGB, T GammaCorrection)
{
return vec<4, T, P>(compute_rgbToSrgb<3, T, P, vec>::call(vec<3, T, P>(ColorRGB), GammaCorrection), ColorRGB.w);
return vec<4, T, P>(compute_rgbToSrgb<3, T, P>::call(vec<3, T, P>(ColorRGB), GammaCorrection), ColorRGB.w);
}
};
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
template<length_t L, typename T, qualifier P>
struct compute_srgbToRgb
{
GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const& ColorSRGB, T Gamma)
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& ColorSRGB, T Gamma)
{
return mix(
pow((ColorSRGB + static_cast<T>(0.055)) * static_cast<T>(0.94786729857819905213270142180095), vecType<L, T, P>(Gamma)),
pow((ColorSRGB + static_cast<T>(0.055)) * static_cast<T>(0.94786729857819905213270142180095), vec<L, T, P>(Gamma)),
ColorSRGB * static_cast<T>(0.07739938080495356037151702786378),
lessThanEqual(ColorSRGB, vecType<L, T, P>(static_cast<T>(0.04045))));
lessThanEqual(ColorSRGB, vec<L, T, P>(static_cast<T>(0.04045))));
}
};
template<typename T, precision P>
struct compute_srgbToRgb<4, T, P, vec>
template<typename T, qualifier P>
struct compute_srgbToRgb<4, T, P>
{
GLM_FUNC_QUALIFIER static vec<4, T, P> call(vec<4, T, P> const& ColorSRGB, T Gamma)
{
return vec<4, T, P>(compute_srgbToRgb<3, T, P, vec>::call(vec<3, T, P>(ColorSRGB), Gamma), ColorSRGB.w);
return vec<4, T, P>(compute_srgbToRgb<3, T, P>::call(vec<3, T, P>(ColorSRGB), Gamma), ColorSRGB.w);
}
};
}//namespace detail
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> convertLinearToSRGB(vecType<L, T, P> const& ColorLinear)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> convertLinearToSRGB(vec<L, T, P> const& ColorLinear)
{
return detail::compute_rgbToSrgb<L, T, P, vecType>::call(ColorLinear, static_cast<T>(0.41666));
return detail::compute_rgbToSrgb<L, T, P>::call(ColorLinear, static_cast<T>(0.41666));
}
// Based on Ian Taylor http://chilliant.blogspot.fr/2012/08/srgb-approximations-for-hlsl.html
@ -65,21 +65,21 @@ namespace detail
return 0.662002687f * S1 + 0.684122060f * S2 - 0.323583601f * S3 - 0.0225411470f * ColorLinear;
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> convertLinearToSRGB(vecType<L, T, P> const& ColorLinear, T Gamma)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> convertLinearToSRGB(vec<L, T, P> const& ColorLinear, T Gamma)
{
return detail::compute_rgbToSrgb<L, T, P, vecType>::call(ColorLinear, static_cast<T>(1) / Gamma);
return detail::compute_rgbToSrgb<L, T, P>::call(ColorLinear, static_cast<T>(1) / Gamma);
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> convertSRGBToLinear(vecType<L, T, P> const& ColorSRGB)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> convertSRGBToLinear(vec<L, T, P> const& ColorSRGB)
{
return detail::compute_srgbToRgb<L, T, P, vecType>::call(ColorSRGB, static_cast<T>(2.4));
return detail::compute_srgbToRgb<L, T, P>::call(ColorSRGB, static_cast<T>(2.4));
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> convertSRGBToLinear(vecType<L, T, P> const& ColorSRGB, T Gamma)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> convertSRGBToLinear(vec<L, T, P> const& ColorSRGB, T Gamma)
{
return detail::compute_srgbToRgb<L, T, P, vecType>::call(ColorSRGB, Gamma);
return detail::compute_srgbToRgb<L, T, P>::call(ColorSRGB, Gamma);
}
}//namespace glm

6
glm/gtc/epsilon.hpp
View File

@ -15,7 +15,7 @@
// Dependencies
#include "../detail/setup.hpp"
#include "../detail/precision.hpp"
#include "../detail/qualifier.hpp"
#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_GTC_epsilon extension included")
@ -30,7 +30,7 @@ namespace glm
/// True if this expression is satisfied.
///
/// @see gtc_epsilon
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, bool, P> epsilonEqual(vec<L, T, P> const& x, vec<L, T, P> const& y, T const & epsilon);
/// Returns the component-wise comparison of |x - y| < epsilon.
@ -44,7 +44,7 @@ namespace glm
/// True if this expression is not satisfied.
///
/// @see gtc_epsilon
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, bool, P> epsilonNotEqual(vec<L, T, P> const& x, vec<L, T, P> const& y, T const & epsilon);
/// Returns the component-wise comparison of |x - y| >= epsilon.

12
glm/gtc/epsilon.inl
View File

@ -33,13 +33,13 @@ namespace glm
return abs(x - y) < epsilon;
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, bool, P> epsilonEqual(vec<L, T, P> const& x, vec<L, T, P> const& y, T const& epsilon)
{
return lessThan(abs(x - y), vec<L, T, P>(epsilon));
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, bool, P> epsilonEqual(vec<L, T, P> const& x, vec<L, T, P> const& y, vec<L, T, P> const& epsilon)
{
return lessThan(abs(x - y), vec<L, T, P>(epsilon));
@ -57,26 +57,26 @@ namespace glm
return abs(x - y) >= epsilon;
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, bool, P> epsilonNotEqual(vec<L, T, P> const& x, vec<L, T, P> const& y, T const& epsilon)
{
return greaterThanEqual(abs(x - y), vec<L, T, P>(epsilon));
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, bool, P> epsilonNotEqual(vec<L, T, P> const& x, vec<L, T, P> const& y, vec<L, T, P> const& epsilon)
{
return greaterThanEqual(abs(x - y), vec<L, T, P>(epsilon));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, bool, P> epsilonEqual(tquat<T, P> const& x, tquat<T, P> const & y, T const& epsilon)
{
vec<4, T, P> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w);
return lessThan(abs(v), vec<4, T, P>(epsilon));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, bool, P> epsilonNotEqual(tquat<T, P> const& x, tquat<T, P> const& y, T const& epsilon)
{
vec<4, T, P> v(x.x - y.x, x.y - y.y, x.z - y.z, x.w - y.w);

4
glm/gtc/functions.hpp
View File

@ -15,7 +15,7 @@
// Dependencies
#include "../detail/setup.hpp"
#include "../detail/precision.hpp"
#include "../detail/qualifier.hpp"
#include "../detail/type_vec2.hpp"
#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
@ -39,7 +39,7 @@ namespace glm
/// 2D gauss function
///
/// @see gtc_epsilon
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL T gauss(
vec<2, T, P> const& Coord,
vec<2, T, P> const& ExpectedValue,

2
glm/gtc/functions.inl
View File

@ -16,7 +16,7 @@ namespace glm
return exp(-((x - ExpectedValue) * (x - ExpectedValue)) / (static_cast<T>(2) * StandardDeviation * StandardDeviation)) / (StandardDeviation * sqrt(static_cast<T>(6.28318530717958647692528676655900576)));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T gauss
(
vec<2, T, P> const& Coord,

10
glm/gtc/integer.hpp
View File

@ -15,7 +15,7 @@
// Dependencies
#include "../detail/setup.hpp"
#include "../detail/precision.hpp"
#include "../detail/qualifier.hpp"
#include "../detail/func_common.hpp"
#include "../detail/func_integer.hpp"
#include "../detail/func_exponential.hpp"
@ -54,7 +54,7 @@ namespace glm
/// @see gtc_integer
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod 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>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> mod(vec<L, T, P> const& x, T y);
/// Modulus. Returns x % y
@ -65,7 +65,7 @@ namespace glm
/// @see gtc_integer
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod 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>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> mod(vec<L, T, P> const& x, vec<L, T, P> const& y);
/// Returns a value equal to the nearest integer to x.
@ -77,7 +77,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/round.xml">GLSL round man page</a>
/// @see gtc_integer
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, int, P> iround(vec<L, T, P> const& x);
/// Returns a value equal to the nearest integer to x.
@ -89,7 +89,7 @@ namespace glm
///
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/round.xml">GLSL round man page</a>
/// @see gtc_integer
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, uint, P> uround(vec<L, T, P> const& x);
/// @}

8
glm/gtc/integer.inl
View File

@ -4,7 +4,7 @@
namespace glm{
namespace detail
{
template<length_t L, typename T, precision P, bool Aligned>
template<length_t L, typename T, qualifier P, bool Aligned>
struct compute_log2<L, T, P, false, Aligned>
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& v)
@ -16,7 +16,7 @@ namespace detail
};
# if GLM_HAS_BITSCAN_WINDOWS
template<precision P, bool Aligned>
template<qualifier P, bool Aligned>
struct compute_log2<4, int, P, false, Aligned>
{
GLM_FUNC_QUALIFIER static vec<4, int, P> call(vec<4, int, P> const& v)
@ -40,7 +40,7 @@ namespace detail
return static_cast<int>(x + static_cast<genType>(0.5));
}
template<glm::length_t L, typename T, precision P>
template<glm::length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, int, P> iround(vec<L, T, P> const& x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'iround' only accept floating-point inputs");
@ -58,7 +58,7 @@ namespace detail
return static_cast<uint>(x + static_cast<genType>(0.5));
}
template<glm::length_t L, typename T, precision P>
template<glm::length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, uint, P> uround(vec<L, T, P> const& x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'uround' only accept floating-point inputs");

144
glm/gtc/matrix_integer.hpp
View File

@ -31,300 +31,300 @@ namespace glm
/// @addtogroup gtc_matrix_integer
/// @{
/// High-precision signed integer 2x2 matrix.
/// High-qualifier signed integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 2, int, highp> highp_imat2;
/// High-precision signed integer 3x3 matrix.
/// High-qualifier signed integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 3, int, highp> highp_imat3;
/// High-precision signed integer 4x4 matrix.
/// High-qualifier signed integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 4, int, highp> highp_imat4;
/// High-precision signed integer 2x2 matrix.
/// High-qualifier signed integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 2, int, highp> highp_imat2x2;
/// High-precision signed integer 2x3 matrix.
/// High-qualifier signed integer 2x3 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 3, int, highp> highp_imat2x3;
/// High-precision signed integer 2x4 matrix.
/// High-qualifier signed integer 2x4 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 4, int, highp> highp_imat2x4;
/// High-precision signed integer 3x2 matrix.
/// High-qualifier signed integer 3x2 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 2, int, highp> highp_imat3x2;
/// High-precision signed integer 3x3 matrix.
/// High-qualifier signed integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 3, int, highp> highp_imat3x3;
/// High-precision signed integer 3x4 matrix.
/// High-qualifier signed integer 3x4 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 4, int, highp> highp_imat3x4;
/// High-precision signed integer 4x2 matrix.
/// High-qualifier signed integer 4x2 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 2, int, highp> highp_imat4x2;
/// High-precision signed integer 4x3 matrix.
/// High-qualifier signed integer 4x3 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 3, int, highp> highp_imat4x3;
/// High-precision signed integer 4x4 matrix.
/// High-qualifier signed integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 4, int, highp> highp_imat4x4;
/// Medium-precision signed integer 2x2 matrix.
/// Medium-qualifier signed integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 2, int, mediump> mediump_imat2;
/// Medium-precision signed integer 3x3 matrix.
/// Medium-qualifier signed integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 3, int, mediump> mediump_imat3;
/// Medium-precision signed integer 4x4 matrix.
/// Medium-qualifier signed integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 4, int, mediump> mediump_imat4;
/// Medium-precision signed integer 2x2 matrix.
/// Medium-qualifier signed integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 2, int, mediump> mediump_imat2x2;
/// Medium-precision signed integer 2x3 matrix.
/// Medium-qualifier signed integer 2x3 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 3, int, mediump> mediump_imat2x3;
/// Medium-precision signed integer 2x4 matrix.
/// Medium-qualifier signed integer 2x4 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 4, int, mediump> mediump_imat2x4;
/// Medium-precision signed integer 3x2 matrix.
/// Medium-qualifier signed integer 3x2 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 2, int, mediump> mediump_imat3x2;
/// Medium-precision signed integer 3x3 matrix.
/// Medium-qualifier signed integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 3, int, mediump> mediump_imat3x3;
/// Medium-precision signed integer 3x4 matrix.
/// Medium-qualifier signed integer 3x4 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 4, int, mediump> mediump_imat3x4;
/// Medium-precision signed integer 4x2 matrix.
/// Medium-qualifier signed integer 4x2 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 2, int, mediump> mediump_imat4x2;
/// Medium-precision signed integer 4x3 matrix.
/// Medium-qualifier signed integer 4x3 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 3, int, mediump> mediump_imat4x3;
/// Medium-precision signed integer 4x4 matrix.
/// Medium-qualifier signed integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 4, int, mediump> mediump_imat4x4;
/// Low-precision signed integer 2x2 matrix.
/// Low-qualifier signed integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 2, int, lowp> lowp_imat2;
/// Low-precision signed integer 3x3 matrix.
/// Low-qualifier signed integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 3, int, lowp> lowp_imat3;
/// Low-precision signed integer 4x4 matrix.
/// Low-qualifier signed integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 4, int, lowp> lowp_imat4;
/// Low-precision signed integer 2x2 matrix.
/// Low-qualifier signed integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 2, int, lowp> lowp_imat2x2;
/// Low-precision signed integer 2x3 matrix.
/// Low-qualifier signed integer 2x3 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 3, int, lowp> lowp_imat2x3;
/// Low-precision signed integer 2x4 matrix.
/// Low-qualifier signed integer 2x4 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 4, int, lowp> lowp_imat2x4;
/// Low-precision signed integer 3x2 matrix.
/// Low-qualifier signed integer 3x2 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 2, int, lowp> lowp_imat3x2;
/// Low-precision signed integer 3x3 matrix.
/// Low-qualifier signed integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 3, int, lowp> lowp_imat3x3;
/// Low-precision signed integer 3x4 matrix.
/// Low-qualifier signed integer 3x4 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 4, int, lowp> lowp_imat3x4;
/// Low-precision signed integer 4x2 matrix.
/// Low-qualifier signed integer 4x2 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 2, int, lowp> lowp_imat4x2;
/// Low-precision signed integer 4x3 matrix.
/// Low-qualifier signed integer 4x3 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 3, int, lowp> lowp_imat4x3;
/// Low-precision signed integer 4x4 matrix.
/// Low-qualifier signed integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 4, int, lowp> lowp_imat4x4;
/// High-precision unsigned integer 2x2 matrix.
/// High-qualifier unsigned integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 2, uint, highp> highp_umat2;
/// High-precision unsigned integer 3x3 matrix.
/// High-qualifier unsigned integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 3, uint, highp> highp_umat3;
/// High-precision unsigned integer 4x4 matrix.
/// High-qualifier unsigned integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 4, uint, highp> highp_umat4;
/// High-precision unsigned integer 2x2 matrix.
/// High-qualifier unsigned integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 2, uint, highp> highp_umat2x2;
/// High-precision unsigned integer 2x3 matrix.
/// High-qualifier unsigned integer 2x3 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 3, uint, highp> highp_umat2x3;
/// High-precision unsigned integer 2x4 matrix.
/// High-qualifier unsigned integer 2x4 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 4, uint, highp> highp_umat2x4;
/// High-precision unsigned integer 3x2 matrix.
/// High-qualifier unsigned integer 3x2 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 2, uint, highp> highp_umat3x2;
/// High-precision unsigned integer 3x3 matrix.
/// High-qualifier unsigned integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 3, uint, highp> highp_umat3x3;
/// High-precision unsigned integer 3x4 matrix.
/// High-qualifier unsigned integer 3x4 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 4, uint, highp> highp_umat3x4;
/// High-precision unsigned integer 4x2 matrix.
/// High-qualifier unsigned integer 4x2 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 2, uint, highp> highp_umat4x2;
/// High-precision unsigned integer 4x3 matrix.
/// High-qualifier unsigned integer 4x3 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 3, uint, highp> highp_umat4x3;
/// High-precision unsigned integer 4x4 matrix.
/// High-qualifier unsigned integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 4, uint, highp> highp_umat4x4;
/// Medium-precision unsigned integer 2x2 matrix.
/// Medium-qualifier unsigned integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 2, uint, mediump> mediump_umat2;
/// Medium-precision unsigned integer 3x3 matrix.
/// Medium-qualifier unsigned integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 3, uint, mediump> mediump_umat3;
/// Medium-precision unsigned integer 4x4 matrix.
/// Medium-qualifier unsigned integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 4, uint, mediump> mediump_umat4;
/// Medium-precision unsigned integer 2x2 matrix.
/// Medium-qualifier unsigned integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 2, uint, mediump> mediump_umat2x2;
/// Medium-precision unsigned integer 2x3 matrix.
/// Medium-qualifier unsigned integer 2x3 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 3, uint, mediump> mediump_umat2x3;
/// Medium-precision unsigned integer 2x4 matrix.
/// Medium-qualifier unsigned integer 2x4 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 4, uint, mediump> mediump_umat2x4;
/// Medium-precision unsigned integer 3x2 matrix.
/// Medium-qualifier unsigned integer 3x2 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 2, uint, mediump> mediump_umat3x2;
/// Medium-precision unsigned integer 3x3 matrix.
/// Medium-qualifier unsigned integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 3, uint, mediump> mediump_umat3x3;
/// Medium-precision unsigned integer 3x4 matrix.
/// Medium-qualifier unsigned integer 3x4 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 4, uint, mediump> mediump_umat3x4;
/// Medium-precision unsigned integer 4x2 matrix.
/// Medium-qualifier unsigned integer 4x2 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 2, uint, mediump> mediump_umat4x2;
/// Medium-precision unsigned integer 4x3 matrix.
/// Medium-qualifier unsigned integer 4x3 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 3, uint, mediump> mediump_umat4x3;
/// Medium-precision unsigned integer 4x4 matrix.
/// Medium-qualifier unsigned integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 4, uint, mediump> mediump_umat4x4;
/// Low-precision unsigned integer 2x2 matrix.
/// Low-qualifier unsigned integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 2, uint, lowp> lowp_umat2;
/// Low-precision unsigned integer 3x3 matrix.
/// Low-qualifier unsigned integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 3, uint, lowp> lowp_umat3;
/// Low-precision unsigned integer 4x4 matrix.
/// Low-qualifier unsigned integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 4, uint, lowp> lowp_umat4;
/// Low-precision unsigned integer 2x2 matrix.
/// Low-qualifier unsigned integer 2x2 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 2, uint, lowp> lowp_umat2x2;
/// Low-precision unsigned integer 2x3 matrix.
/// Low-qualifier unsigned integer 2x3 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 3, uint, lowp> lowp_umat2x3;
/// Low-precision unsigned integer 2x4 matrix.
/// Low-qualifier unsigned integer 2x4 matrix.
/// @see gtc_matrix_integer
typedef mat<2, 4, uint, lowp> lowp_umat2x4;
/// Low-precision unsigned integer 3x2 matrix.
/// Low-qualifier unsigned integer 3x2 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 2, uint, lowp> lowp_umat3x2;
/// Low-precision unsigned integer 3x3 matrix.
/// Low-qualifier unsigned integer 3x3 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 3, uint, lowp> lowp_umat3x3;
/// Low-precision unsigned integer 3x4 matrix.
/// Low-qualifier unsigned integer 3x4 matrix.
/// @see gtc_matrix_integer
typedef mat<3, 4, uint, lowp> lowp_umat3x4;
/// Low-precision unsigned integer 4x2 matrix.
/// Low-qualifier unsigned integer 4x2 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 2, uint, lowp> lowp_umat4x2;
/// Low-precision unsigned integer 4x3 matrix.
/// Low-qualifier unsigned integer 4x3 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 3, uint, lowp> lowp_umat4x3;
/// Low-precision unsigned integer 4x4 matrix.
/// Low-qualifier unsigned integer 4x4 matrix.
/// @see gtc_matrix_integer
typedef mat<4, 4, uint, lowp> lowp_umat4x4;

4
glm/gtc/matrix_inverse.hpp
View File

@ -30,7 +30,7 @@ namespace glm
/// Fast matrix inverse for affine matrix.
///
/// @param m Input matrix to invert.
/// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-precision floating point value is highly innacurate.
/// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-qualifier floating point value is highly innacurate.
/// @see gtc_matrix_inverse
template<typename genType>
GLM_FUNC_DECL genType affineInverse(genType const & m);
@ -38,7 +38,7 @@ namespace glm
/// Compute the inverse transpose of a matrix.
///
/// @param m Input matrix to invert transpose.
/// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-precision floating point value is highly innacurate.
/// @tparam genType Squared floating-point matrix: half, float or double. Inverse of matrix based of half-qualifier floating point value is highly innacurate.
/// @see gtc_matrix_inverse
template<typename genType>
GLM_FUNC_DECL genType inverseTranspose(genType const & m);

10
glm/gtc/matrix_inverse.inl
View File

@ -3,7 +3,7 @@
namespace glm
{
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> affineInverse(mat<3, 3, T, P> const & m)
{
mat<2, 2, T, P> const Inv(inverse(mat<2, 2, T, P>(m)));
@ -14,7 +14,7 @@ namespace glm
vec<3, T, P>(-Inv * vec<2, T, P>(m[2]), static_cast<T>(1)));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> affineInverse(mat<4, 4, T, P> const & m)
{
mat<3, 3, T, P> const Inv(inverse(mat<3, 3, T, P>(m)));
@ -26,7 +26,7 @@ namespace glm
vec<4, T, P>(-Inv * vec<3, T, P>(m[3]), static_cast<T>(1)));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<2, 2, T, P> inverseTranspose(mat<2, 2, T, P> const & m)
{
T Determinant = m[0][0] * m[1][1] - m[1][0] * m[0][1];
@ -40,7 +40,7 @@ namespace glm
return Inverse;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> inverseTranspose(mat<3, 3, T, P> const & m)
{
T Determinant =
@ -63,7 +63,7 @@ namespace glm
return Inverse;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> inverseTranspose(mat<4, 4, T, P> const & m)
{
T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];

18
glm/gtc/matrix_transform.hpp
View File

@ -54,7 +54,7 @@ namespace glm
/// @see gtc_matrix_transform
/// @see - translate(mat<4, 4, T, P> const & m, T x, T y, T z)
/// @see - translate(vec<3, T, P> const & v)
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> translate(
mat<4, 4, T, P> const& m,
vec<3, T, P> const & v);
@ -68,7 +68,7 @@ namespace glm
/// @see gtc_matrix_transform
/// @see - rotate(mat<4, 4, T, P> const & m, T angle, T x, T y, T z)
/// @see - rotate(T angle, vec<3, T, P> const & v)
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> rotate(
mat<4, 4, T, P> const& m,
T angle,
@ -82,7 +82,7 @@ namespace glm
/// @see gtc_matrix_transform
/// @see - scale(mat<4, 4, T, P> const & m, T x, T y, T z)
/// @see - scale(vec<3, T, P> const & v)
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> scale(
mat<4, 4, T, P> const& m,
vec<3, T, P> const & v);
@ -382,7 +382,7 @@ namespace glm
/// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double.
/// @tparam U Currently supported: Floating-point types and integer types.
/// @see gtc_matrix_transform
template<typename T, typename U, precision P>
template<typename T, typename U, qualifier P>
GLM_FUNC_DECL vec<3, T, P> project(
vec<3, T, P> const & obj,
mat<4, 4, T, P> const& model,
@ -399,7 +399,7 @@ namespace glm
/// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double.
/// @tparam U Currently supported: Floating-point types and integer types.
/// @see gtc_matrix_transform
template<typename T, typename U, precision P>
template<typename T, typename U, qualifier P>
GLM_FUNC_DECL vec<3, T, P> unProject(
vec<3, T, P> const & win,
mat<4, 4, T, P> const& model,
@ -414,7 +414,7 @@ namespace glm
/// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double.
/// @tparam U Currently supported: Floating-point types and integer types.
/// @see gtc_matrix_transform
template<typename T, precision P, typename U>
template<typename T, qualifier P, typename U>
GLM_FUNC_DECL mat<4, 4, T, P> pickMatrix(
vec<2, T, P> const & center,
vec<2, T, P> const & delta,
@ -427,7 +427,7 @@ namespace glm
/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1)
/// @see gtc_matrix_transform
/// @see - frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal) frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal)
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> lookAt(
vec<3, T, P> const & eye,
vec<3, T, P> const & center,
@ -440,7 +440,7 @@ namespace glm
/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1)
/// @see gtc_matrix_transform
/// @see - frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal) frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal)
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> lookAtRH(
vec<3, T, P> const & eye,
vec<3, T, P> const & center,
@ -453,7 +453,7 @@ namespace glm
/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1)
/// @see gtc_matrix_transform
/// @see - frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal) frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal)
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> lookAtLH(
vec<3, T, P> const & eye,
vec<3, T, P> const & center,

22
glm/gtc/matrix_transform.inl
View File

@ -7,7 +7,7 @@
namespace glm
{
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> translate(mat<4, 4, T, P> const & m, vec<3, T, P> const & v)
{
mat<4, 4, T, P> Result(m);
@ -15,7 +15,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> rotate(mat<4, 4, T, P> const & m, T angle, vec<3, T, P> const & v)
{
T const a = angle;
@ -46,7 +46,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> rotate_slow(mat<4, 4, T, P> const & m, T angle, vec<3, T, P> const & v)
{
T const a = angle;
@ -75,7 +75,7 @@ namespace glm
return m * Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> scale(mat<4, 4, T, P> const & m, vec<3, T, P> const & v)
{
mat<4, 4, T, P> Result;
@ -86,7 +86,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> scale_slow(mat<4, 4, T, P> const & m, vec<3, T, P> const & v)
{
mat<4, 4, T, P> Result(T(1));
@ -435,7 +435,7 @@ namespace glm
return tweakedInfinitePerspective(fovy, aspect, zNear, epsilon<T>());
}
template<typename T, typename U, precision P>
template<typename T, typename U, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> project
(
vec<3, T, P> const & obj,
@ -461,7 +461,7 @@ namespace glm
return vec<3, T, P>(tmp);
}
template<typename T, typename U, precision P>
template<typename T, typename U, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> unProject
(
vec<3, T, P> const & win,
@ -488,7 +488,7 @@ namespace glm
return vec<3, T, P>(obj);
}
template<typename T, precision P, typename U>
template<typename T, qualifier P, typename U>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> pickMatrix(vec<2, T, P> const & center, vec<2, T, P> const & delta, vec<4, U, P> const & viewport)
{
assert(delta.x > static_cast<T>(0) && delta.y > static_cast<T>(0));
@ -507,7 +507,7 @@ namespace glm
return scale(Result, vec<3, T, P>(static_cast<T>(viewport[2]) / delta.x, static_cast<T>(viewport[3]) / delta.y, static_cast<T>(1)));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> lookAt(vec<3, T, P> const & eye, vec<3, T, P> const & center, vec<3, T, P> const & up)
{
# if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
@ -517,7 +517,7 @@ namespace glm
# endif
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> lookAtRH
(
vec<3, T, P> const & eye,
@ -545,7 +545,7 @@ namespace glm
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> lookAtLH
(
vec<3, T, P> const & eye,

16
glm/gtc/noise.hpp
View File

@ -17,7 +17,7 @@
// Dependencies
#include "../detail/setup.hpp"
#include "../detail/precision.hpp"
#include "../detail/qualifier.hpp"
#include "../detail/_noise.hpp"
#include "../geometric.hpp"
#include "../common.hpp"
@ -37,22 +37,22 @@ namespace glm
/// Classic perlin noise.
/// @see gtc_noise
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL T perlin(
vecType<L, T, P> const& p);
vec<L, T, P> const& p);
/// Periodic perlin noise.
/// @see gtc_noise
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL T perlin(
vecType<L, T, P> const& p,
vecType<L, T, P> const& rep);
vec<L, T, P> const& p,
vec<L, T, P> const& rep);
/// Simplex noise.
/// @see gtc_noise
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL T simplex(
vecType<L, T, P> const& p);
vec<L, T, P> const& p);
/// @}
}//namespace glm

22
glm/gtc/noise.inl
View File

@ -9,7 +9,7 @@
namespace glm{
namespace gtc
{
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> grad4(T const & j, vec<4, T, P> const & ip)
{
vec<3, T, P> pXYZ = floor(fract(vec<3, T, P>(j) * vec<3, T, P>(ip)) * T(7)) * ip[2] - T(1);
@ -21,7 +21,7 @@ namespace gtc
}//namespace gtc
// Classic Perlin noise
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T perlin(vec<2, T, P> const & Position)
{
vec<4, T, P> Pi = glm::floor(vec<4, T, P>(Position.x, Position.y, Position.x, Position.y)) + vec<4, T, P>(0.0, 0.0, 1.0, 1.0);
@ -62,7 +62,7 @@ namespace gtc
}
// Classic Perlin noise
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T perlin(vec<3, T, P> const & Position)
{
vec<3, T, P> Pi0 = floor(Position); // Integer part for indexing
@ -133,7 +133,7 @@ namespace gtc
}
/*
// Classic Perlin noise
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T perlin(vec<3, T, P> const & P)
{
vec<3, T, P> Pi0 = floor(P); // Integer part for indexing
@ -206,7 +206,7 @@ namespace gtc
}
*/
// Classic Perlin noise
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T perlin(vec<4, T, P> const & Position)
{
vec<4, T, P> Pi0 = floor(Position); // Integer part for indexing
@ -342,7 +342,7 @@ namespace gtc
}
// Classic Perlin noise, periodic variant
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T perlin(vec<2, T, P> const & Position, vec<2, T, P> const & rep)
{
vec<4, T, P> Pi = floor(vec<4, T, P>(Position.x, Position.y, Position.x, Position.y)) + vec<4, T, P>(0.0, 0.0, 1.0, 1.0);
@ -384,7 +384,7 @@ namespace gtc
}
// Classic Perlin noise, periodic variant
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T perlin(vec<3, T, P> const & Position, vec<3, T, P> const & rep)
{
vec<3, T, P> Pi0 = mod(floor(Position), rep); // Integer part, modulo period
@ -455,7 +455,7 @@ namespace gtc
}
// Classic Perlin noise, periodic version
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T perlin(vec<4, T, P> const & Position, vec<4, T, P> const & rep)
{
vec<4, T, P> Pi0 = mod(floor(Position), rep); // Integer part modulo rep
@ -588,7 +588,7 @@ namespace gtc
return T(2.2) * n_xyzw;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T simplex(glm::vec<2, T, P> const & v)
{
vec<4, T, P> const C = vec<4, T, P>(
@ -645,7 +645,7 @@ namespace gtc
return T(130) * dot(m, g);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T simplex(vec<3, T, P> const & v)
{
vec<2, T, P> const C(1.0 / 6.0, 1.0 / 3.0);
@ -720,7 +720,7 @@ namespace gtc
return T(42) * dot(m * m, vec<4, T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T simplex(vec<4, T, P> const & v)
{
vec<4, T, P> const C(

32
glm/gtc/packing.hpp
View File

@ -477,7 +477,7 @@ namespace glm
/// @see gtc_packing
/// @see vec<3, T, P> unpackRGBM(vec<4, T, P> const & p)
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> packRGBM(vec<3, T, P> const & rgb);
/// Returns a floating-point vector with components obtained by reinterpreting an integer vector as 16-bit floating-point numbers and converting them to 32-bit floating-point values.
@ -487,7 +487,7 @@ namespace glm
/// @see gtc_packing
/// @see vec<4, T, P> packRGBM(vec<3, float, P> const & v)
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> unpackRGBM(vec<4, T, P> const & rgbm);
/// Returns an unsigned integer vector obtained by converting the components of a floating-point vector
@ -496,47 +496,47 @@ namespace glm
/// the forth component specifies the 16 most-significant bits.
///
/// @see gtc_packing
/// @see vecType<L, float, P> unpackHalf(vecType<L, uint16, P> const & p)
/// @see vec<L, float, P> unpackHalf(vec<L, uint16, P> const & p)
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
template<length_t L, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, uint16, P> packHalf(vecType<L, float, P> const & v);
template<length_t L, qualifier P>
GLM_FUNC_DECL vec<L, uint16, P> packHalf(vec<L, float, P> const & v);
/// Returns a floating-point vector with components obtained by reinterpreting an integer vector as 16-bit floating-point numbers and converting them to 32-bit floating-point values.
/// The first component of the vector is obtained from the 16 least-significant bits of v;
/// the forth component is obtained from the 16 most-significant bits of v.
///
/// @see gtc_packing
/// @see vecType<L, uint16, P> packHalf(vecType<L, float, P> const & v)
/// @see vec<L, uint16, P> packHalf(vec<L, float, P> const & v)
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
template<length_t L, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, float, P> unpackHalf(vecType<L, uint16, P> const & p);
template<length_t L, qualifier P>
GLM_FUNC_DECL vec<L, float, P> unpackHalf(vec<L, uint16, P> const & p);
/// Convert each component of the normalized floating-point vector into unsigned integer values.
///
/// @see gtc_packing
/// @see vecType<L, floatType, P> unpackUnorm(vecType<L, intType, P> const & p);
template<typename uintType, length_t L, typename floatType, precision P>
/// @see vec<L, floatType, P> unpackUnorm(vec<L, intType, P> const & p);
template<typename uintType, length_t L, typename floatType, qualifier P>
GLM_FUNC_DECL vec<L, uintType, P> packUnorm(vec<L, floatType, P> const & v);
/// Convert a packed integer to a normalized floating-point vector.
///
/// @see gtc_packing
/// @see vecType<L, intType, P> packUnorm(vecType<L, floatType, P> const & v)
template<typename floatType, length_t L, typename uintType, precision P>
/// @see vec<L, intType, P> packUnorm(vec<L, floatType, P> const & v)
template<typename floatType, length_t L, typename uintType, qualifier P>
GLM_FUNC_DECL vec<L, floatType, P> unpackUnorm(vec<L, uintType, P> const & v);
/// Convert each component of the normalized floating-point vector into signed integer values.
///
/// @see gtc_packing
/// @see vecType<L, floatType, P> unpackSnorm(vecType<L, intType, P> const & p);
template<typename intType, length_t L, typename floatType, precision P>
/// @see vec<L, floatType, P> unpackSnorm(vec<L, intType, P> const & p);
template<typename intType, length_t L, typename floatType, qualifier P>
GLM_FUNC_DECL vec<L, intType, P> packSnorm(vec<L, floatType, P> const & v);
/// Convert a packed integer to a normalized floating-point vector.
///
/// @see gtc_packing
/// @see vecType<L, intType, P> packSnorm(vecType<L, floatType, P> const & v)
template<typename floatType, length_t L, typename intType, precision P>
/// @see vec<L, intType, P> packSnorm(vec<L, floatType, P> const & v)
template<typename floatType, length_t L, typename intType, qualifier P>
GLM_FUNC_DECL vec<L, floatType, P> unpackSnorm(vec<L, intType, P> const & v);
/// Convert each component of the normalized floating-point vector into unsigned integer values.

42
glm/gtc/packing.inl
View File

@ -271,12 +271,12 @@ namespace detail
uint32 pack;
};
template<length_t L, precision P, template<length_t, typename, precision> class vecType>
template<length_t L, qualifier P>
struct compute_half
{};
template<precision P>
struct compute_half<1, P, vec>
template<qualifier P>
struct compute_half<1, P>
{
GLM_FUNC_QUALIFIER static vec<1, uint16, P> pack(vec<1, float, P> const & v)
{
@ -294,8 +294,8 @@ namespace detail
}
};
template<precision P>
struct compute_half<2, P, vec>
template<qualifier P>
struct compute_half<2, P>
{
GLM_FUNC_QUALIFIER static vec<2, uint16, P> pack(vec<2, float, P> const & v)
{
@ -313,8 +313,8 @@ namespace detail
}
};
template<precision P>
struct compute_half<3, P, vec>
template<qualifier P>
struct compute_half<3, P>
{
GLM_FUNC_QUALIFIER static vec<3, uint16, P> pack(vec<3, float, P> const & v)
{
@ -332,8 +332,8 @@ namespace detail
}
};
template<precision P>
struct compute_half<4, P, vec>
template<qualifier P>
struct compute_half<4, P>
{
GLM_FUNC_QUALIFIER static vec<4, uint16, P> pack(vec<4, float, P> const & v)
{
@ -641,7 +641,7 @@ namespace detail
}
// Based on Brian Karis http://graphicrants.blogspot.fr/2009/04/rgbm-color-encoding.html
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> packRGBM(vec<3, T, P> const & rgb)
{
vec<3, T, P> const Color(rgb * static_cast<T>(1.0 / 6.0));
@ -650,25 +650,25 @@ namespace detail
return vec<4, T, P>(Color / Alpha, Alpha);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> unpackRGBM(vec<4, T, P> const & rgbm)
{
return vec<3, T, P>(rgbm.x, rgbm.y, rgbm.z) * rgbm.w * static_cast<T>(6);
}
template<length_t L, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, uint16, P> packHalf(vecType<L, float, P> const & v)
template<length_t L, qualifier P>
GLM_FUNC_QUALIFIER vec<L, uint16, P> packHalf(vec<L, float, P> const & v)
{
return detail::compute_half<L, P, vecType>::pack(v);
return detail::compute_half<L, P>::pack(v);
}
template<length_t L, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, float, P> unpackHalf(vecType<L, uint16, P> const & v)
template<length_t L, qualifier P>
GLM_FUNC_QUALIFIER vec<L, float, P> unpackHalf(vec<L, uint16, P> const & v)
{
return detail::compute_half<L, P, vecType>::unpack(v);
return detail::compute_half<L, P>::unpack(v);
}
template<typename uintType, length_t L, typename floatType, precision P>
template<typename uintType, length_t L, typename floatType, qualifier P>
GLM_FUNC_QUALIFIER vec<L, uintType, P> packUnorm(vec<L, floatType, P> const& v)
{
GLM_STATIC_ASSERT(std::numeric_limits<uintType>::is_integer, "uintType must be an integer type");
@ -677,7 +677,7 @@ namespace detail
return vec<L, uintType, P>(round(clamp(v, static_cast<floatType>(0), static_cast<floatType>(1)) * static_cast<floatType>(std::numeric_limits<uintType>::max())));
}
template<typename floatType, length_t L, typename uintType, precision P>
template<typename floatType, length_t L, typename uintType, qualifier P>
GLM_FUNC_QUALIFIER vec<L, floatType, P> unpackUnorm(vec<L, uintType, P> const& v)
{
GLM_STATIC_ASSERT(std::numeric_limits<uintType>::is_integer, "uintType must be an integer type");
@ -686,7 +686,7 @@ namespace detail
return vec<L, float, P>(v) * (static_cast<floatType>(1) / static_cast<floatType>(std::numeric_limits<uintType>::max()));
}
template<typename intType, length_t L, typename floatType, precision P>
template<typename intType, length_t L, typename floatType, qualifier P>
GLM_FUNC_QUALIFIER vec<L, intType, P> packSnorm(vec<L, floatType, P> const & v)
{
GLM_STATIC_ASSERT(std::numeric_limits<intType>::is_integer, "uintType must be an integer type");
@ -695,7 +695,7 @@ namespace detail
return vec<L, intType, P>(round(clamp(v , static_cast<floatType>(-1), static_cast<floatType>(1)) * static_cast<floatType>(std::numeric_limits<intType>::max())));
}
template<typename floatType, length_t L, typename intType, precision P>
template<typename floatType, length_t L, typename intType, qualifier P>
GLM_FUNC_QUALIFIER vec<L, floatType, P> unpackSnorm(vec<L, intType, P> const & v)
{
GLM_STATIC_ASSERT(std::numeric_limits<intType>::is_integer, "uintType must be an integer type");

88
glm/gtc/quaternion.hpp
View File

@ -29,7 +29,7 @@ namespace glm
/// @addtogroup gtc_quaternion
/// @{
template<typename T, precision P = defaultp>
template<typename T, qualifier P = defaultp>
struct tquat
{
// -- Implementation detail --
@ -79,7 +79,7 @@ namespace glm
GLM_FUNC_DECL GLM_CONSTEXPR tquat() GLM_DEFAULT;
GLM_FUNC_DECL GLM_CONSTEXPR tquat(tquat<T, P> const& q) GLM_DEFAULT;
template<precision Q>
template<qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR tquat(tquat<T, Q> const& q);
// -- Explicit basic constructors --
@ -89,7 +89,7 @@ namespace glm
// -- Conversion constructors --
template<typename U, precision Q>
template<typename U, qualifier Q>
GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tquat(tquat<U, Q> const& q);
/// Explicit conversion operators
@ -131,47 +131,47 @@ namespace glm
// -- Unary bit operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL tquat<T, P> operator+(tquat<T, P> const& q);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL tquat<T, P> operator-(tquat<T, P> const& q);
// -- Binary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL tquat<T, P> operator+(tquat<T, P> const & q, tquat<T, P> const & p);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL tquat<T, P> operator*(tquat<T, P> const & q, tquat<T, P> const & p);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator*(tquat<T, P> const & q, vec<3, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> operator*(vec<3, T, P> const & v, tquat<T, P> const & q);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator*(tquat<T, P> const & q, vec<4, T, P> const & v);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> operator*(vec<4, T, P> const & v, tquat<T, P> const & q);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL tquat<T, P> operator*(tquat<T, P> const & q, T const & s);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL tquat<T, P> operator*(T const & s, tquat<T, P> const & q);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL tquat<T, P> operator/(tquat<T, P> const & q, T const & s);
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator==(tquat<T, P> const & q1, tquat<T, P> const & q2);
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL bool operator!=(tquat<T, P> const & q1, tquat<T, P> const & q2);
/// Returns the length of the quaternion.
@ -179,7 +179,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL T length(tquat<T, P> const & q);
/// Returns the normalized quaternion.
@ -187,7 +187,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL tquat<T, P> normalize(tquat<T, P> const & q);
/// Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ...
@ -195,7 +195,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL T dot(tquat<T, P> const & x, tquat<T, P> const & y);
/// Spherical linear interpolation of two quaternions.
@ -209,7 +209,7 @@ namespace glm
///
/// @see - slerp(tquat<T, P> const & x, tquat<T, P> const & y, T const & a)
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL tquat<T, P> mix(tquat<T, P> const & x, tquat<T, P> const & y, T a);
/// Linear interpolation of two quaternions.
@ -221,7 +221,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL tquat<T, P> lerp(tquat<T, P> const & x, tquat<T, P> const & y, T a);
/// Spherical linear interpolation of two quaternions.
@ -233,7 +233,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL tquat<T, P> slerp(tquat<T, P> const & x, tquat<T, P> const & y, T a);
/// Returns the q conjugate.
@ -241,7 +241,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL tquat<T, P> conjugate(tquat<T, P> const & q);
/// Returns the q inverse.
@ -249,7 +249,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL tquat<T, P> inverse(tquat<T, P> const & q);
/// Rotates a quaternion from a vector of 3 components axis and an angle.
@ -260,7 +260,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL tquat<T, P> rotate(tquat<T, P> const & q, T const & angle, vec<3, T, P> const & axis);
/// Returns euler angles, pitch as x, yaw as y, roll as z.
@ -269,7 +269,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> eulerAngles(tquat<T, P> const & x);
/// Returns roll value of euler angles expressed in radians.
@ -277,7 +277,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL T roll(tquat<T, P> const& x);
/// Returns pitch value of euler angles expressed in radians.
@ -285,7 +285,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL T pitch(tquat<T, P> const& x);
/// Returns yaw value of euler angles expressed in radians.
@ -293,7 +293,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL T yaw(tquat<T, P> const& x);
/// Converts a quaternion to a 3 * 3 matrix.
@ -301,7 +301,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<3, 3, T, P> mat3_cast(tquat<T, P> const& x);
/// Converts a quaternion to a 4 * 4 matrix.
@ -309,7 +309,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL mat<4, 4, T, P> mat4_cast(tquat<T, P> const& x);
/// Converts a 3 * 3 matrix to a quaternion.
@ -317,7 +317,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL tquat<T, P> quat_cast(mat<3, 3, T, P> const& x);
/// Converts a 4 * 4 matrix to a quaternion.
@ -325,7 +325,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL tquat<T, P> quat_cast(mat<4, 4, T, P> const& x);
/// Returns the quaternion rotation angle.
@ -333,7 +333,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL T angle(tquat<T, P> const& x);
/// Returns the q rotation axis.
@ -341,7 +341,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> axis(tquat<T, P> const& x);
/// Build a quaternion from an angle and a normalized axis.
@ -351,7 +351,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL tquat<T, P> angleAxis(T const& angle, vec<3, T, P> const& axis);
/// Returns the component-wise comparison result of x < y.
@ -359,7 +359,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, bool, P> lessThan(tquat<T, P> const& x, tquat<T, P> const& y);
/// Returns the component-wise comparison of result x <= y.
@ -367,7 +367,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, bool, P> lessThanEqual(tquat<T, P> const& x, tquat<T, P> const& y);
/// Returns the component-wise comparison of result x > y.
@ -375,7 +375,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, bool, P> greaterThan(tquat<T, P> const& x, tquat<T, P> const& y);
/// Returns the component-wise comparison of result x >= y.
@ -383,7 +383,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, bool, P> greaterThanEqual(tquat<T, P> const& x, tquat<T, P> const& y);
/// Returns the component-wise comparison of result x == y.
@ -391,7 +391,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, bool, P> equal(tquat<T, P> const& x, tquat<T, P> const& y);
/// Returns the component-wise comparison of result x != y.
@ -399,7 +399,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, bool, P> notEqual(tquat<T, P> const& x, tquat<T, P> const& y);
/// Returns true if x holds a NaN (not a number)
@ -413,7 +413,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, bool, P> isnan(tquat<T, P> const& x);
/// Returns true if x holds a positive infinity or negative
@ -425,7 +425,7 @@ namespace glm
/// @tparam T Floating-point scalar types.
///
/// @see gtc_quaternion
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, bool, P> isinf(tquat<T, P> const& x);
/// @}

144
glm/gtc/quaternion.inl
View File

@ -11,7 +11,7 @@
namespace glm{
namespace detail
{
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_dot<tquat<T, P>, T, Aligned>
{
static GLM_FUNC_QUALIFIER T call(tquat<T, P> const& a, tquat<T, P> const& b)
@ -21,7 +21,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_quat_add
{
static tquat<T, P> call(tquat<T, P> const& q, tquat<T, P> const& p)
@ -30,7 +30,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_quat_sub
{
static tquat<T, P> call(tquat<T, P> const& q, tquat<T, P> const& p)
@ -39,7 +39,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_quat_mul_scalar
{
static tquat<T, P> call(tquat<T, P> const& q, T s)
@ -48,7 +48,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_quat_div_scalar
{
static tquat<T, P> call(tquat<T, P> const& q, T s)
@ -57,7 +57,7 @@ namespace detail
}
};
template<typename T, precision P, bool Aligned>
template<typename T, qualifier P, bool Aligned>
struct compute_quat_mul_vec4
{
static vec<4, T, P> call(tquat<T, P> const & q, vec<4, T, P> const & v)
@ -69,14 +69,14 @@ namespace detail
// -- Component accesses --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T & tquat<T, P>::operator[](typename tquat<T, P>::length_type i)
{
assert(i >= 0 && i < this->length());
return (&x)[i];
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T const & tquat<T, P>::operator[](typename tquat<T, P>::length_type i) const
{
assert(i >= 0 && i < this->length());
@ -86,40 +86,40 @@ namespace detail
// -- Implicit basic constructors --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat()
{}
# endif
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat(tquat<T, P> const & q)
: x(q.x), y(q.y), z(q.z), w(q.w)
{}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<precision Q>
template<typename T, qualifier P>
template<qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat(tquat<T, Q> const& q)
: x(q.x), y(q.y), z(q.z), w(q.w)
{}
// -- Explicit basic constructors --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat(T s, vec<3, T, P> const& v)
: x(v.x), y(v.y), z(v.z), w(s)
{}
template <typename T, precision P>
template <typename T, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat(T _w, T _x, T _y, T _z)
: x(_x), y(_y), z(_z), w(_w)
{}
// -- Conversion constructors --
template<typename T, precision P>
template<typename U, precision Q>
template<typename T, qualifier P>
template<typename U, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tquat<T, P>::tquat(tquat<U, Q> const& q)
: x(static_cast<T>(q.x))
, y(static_cast<T>(q.y))
@ -145,7 +145,7 @@ namespace detail
// this->z = c.x * c.y * s.z - s.x * s.y * c.z;
//}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P>::tquat(vec<3, T, P> const& u, vec<3, T, P> const& v)
{
vec<3, T, P> const LocalW(cross(u, v));
@ -155,7 +155,7 @@ namespace detail
*this = normalize(q);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P>::tquat(vec<3, T, P> const& eulerAngle)
{
vec<3, T, P> c = glm::cos(eulerAngle * T(0.5));
@ -167,39 +167,39 @@ namespace detail
this->z = c.x * c.y * s.z - s.x * s.y * c.z;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P>::tquat(mat<3, 3, T, P> const& m)
{
*this = quat_cast(m);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P>::tquat(mat<4, 4, T, P> const& m)
{
*this = quat_cast(m);
}
# if GLM_HAS_EXPLICIT_CONVERSION_OPERATORS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P>::operator mat<3, 3, T, P>()
{
return mat3_cast(*this);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P>::operator mat<4, 4, T, P>()
{
return mat4_cast(*this);
}
# endif//GLM_HAS_EXPLICIT_CONVERSION_OPERATORS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P> conjugate(tquat<T, P> const& q)
{
return tquat<T, P>(q.w, -q.x, -q.y, -q.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P> inverse(tquat<T, P> const & q)
{
return conjugate(q) / dot(q, q);
@ -208,7 +208,7 @@ namespace detail
// -- Unary arithmetic operators --
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P> & tquat<T, P>::operator=(tquat<T, P> const & q)
{
this->w = q.w;
@ -219,7 +219,7 @@ namespace detail
}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER tquat<T, P> & tquat<T, P>::operator=(tquat<U, P> const & q)
{
@ -230,21 +230,21 @@ namespace detail
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER tquat<T, P> & tquat<T, P>::operator+=(tquat<U, P> const& q)
{
return (*this = detail::compute_quat_add<T, P, detail::is_aligned<P>::value>::call(*this, tquat<T, P>(q)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER tquat<T, P> & tquat<T, P>::operator-=(tquat<U, P> const& q)
{
return (*this = detail::compute_quat_sub<T, P, detail::is_aligned<P>::value>::call(*this, tquat<T, P>(q)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER tquat<T, P> & tquat<T, P>::operator*=(tquat<U, P> const & r)
{
@ -258,14 +258,14 @@ namespace detail
return *this;
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER tquat<T, P> & tquat<T, P>::operator*=(U s)
{
return (*this = detail::compute_quat_mul_scalar<T, P, detail::is_aligned<P>::value>::call(*this, static_cast<U>(s)));
}
template<typename T, precision P>
template<typename T, qualifier P>
template<typename U>
GLM_FUNC_QUALIFIER tquat<T, P> & tquat<T, P>::operator/=(U s)
{
@ -274,13 +274,13 @@ namespace detail
// -- Unary bit operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P> operator+(tquat<T, P> const & q)
{
return q;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P> operator-(tquat<T, P> const & q)
{
return tquat<T, P>(-q.w, -q.x, -q.y, -q.z);
@ -288,19 +288,19 @@ namespace detail
// -- Binary operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P> operator+(tquat<T, P> const & q, tquat<T, P> const & p)
{
return tquat<T, P>(q) += p;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P> operator*(tquat<T, P> const & q, tquat<T, P> const & p)
{
return tquat<T, P>(q) *= p;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator*(tquat<T, P> const & q, vec<3, T, P> const & v)
{
vec<3, T, P> const QuatVector(q.x, q.y, q.z);
@ -310,38 +310,38 @@ namespace detail
return v + ((uv * q.w) + uuv) * static_cast<T>(2);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> operator*(vec<3, T, P> const & v, tquat<T, P> const & q)
{
return glm::inverse(q) * v;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator*(tquat<T, P> const& q, vec<4, T, P> const& v)
{
return detail::compute_quat_mul_vec4<T, P, detail::is_aligned<P>::value>::call(q, v);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> operator*(vec<4, T, P> const & v, tquat<T, P> const & q)
{
return glm::inverse(q) * v;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P> operator*(tquat<T, P> const & q, T const & s)
{
return tquat<T, P>(
q.w * s, q.x * s, q.y * s, q.z * s);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P> operator*(T const & s, tquat<T, P> const & q)
{
return q * s;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P> operator/(tquat<T, P> const & q, T const & s)
{
return tquat<T, P>(
@ -350,13 +350,13 @@ namespace detail
// -- Boolean operators --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator==(tquat<T, P> const & q1, tquat<T, P> const & q2)
{
return all(epsilonEqual(q1, q2, epsilon<T>()));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER bool operator!=(tquat<T, P> const & q1, tquat<T, P> const & q2)
{
return any(epsilonNotEqual(q1, q2, epsilon<T>()));
@ -364,13 +364,13 @@ namespace detail
// -- Operations --
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T length(tquat<T, P> const & q)
{
return glm::sqrt(dot(q, q));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P> normalize(tquat<T, P> const & q)
{
T len = length(q);
@ -380,7 +380,7 @@ namespace detail
return tquat<T, P>(q.w * oneOverLen, q.x * oneOverLen, q.y * oneOverLen, q.z * oneOverLen);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P> cross(tquat<T, P> const & q1, tquat<T, P> const & q2)
{
return tquat<T, P>(
@ -391,7 +391,7 @@ namespace detail
}
/*
// (x * sin(1 - a) * angle / sin(angle)) + (y * sin(a) * angle / sin(angle))
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P> mix(tquat<T, P> const & x, tquat<T, P> const & y, T const & a)
{
if(a <= T(0)) return x;
@ -428,7 +428,7 @@ namespace detail
k0 * x.z + k1 * y2.z);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P> mix2
(
tquat<T, P> const & x,
@ -466,7 +466,7 @@ namespace detail
}
*/
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P> mix(tquat<T, P> const & x, tquat<T, P> const & y, T a)
{
T cosTheta = dot(x, y);
@ -489,7 +489,7 @@ namespace detail
}
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P> lerp(tquat<T, P> const & x, tquat<T, P> const & y, T a)
{
// Lerp is only defined in [0, 1]
@ -499,7 +499,7 @@ namespace detail
return x * (T(1) - a) + (y * a);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P> slerp(tquat<T, P> const & x, tquat<T, P> const & y, T a)
{
tquat<T, P> z = y;
@ -532,7 +532,7 @@ namespace detail
}
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P> rotate(tquat<T, P> const & q, T const & angle, vec<3, T, P> const & v)
{
vec<3, T, P> Tmp = v;
@ -554,19 +554,19 @@ namespace detail
//return gtc::quaternion::cross(q, tquat<T, P>(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> eulerAngles(tquat<T, P> const & x)
{
return vec<3, T, P>(pitch(x), yaw(x), roll(x));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T roll(tquat<T, P> const & q)
{
return static_cast<T>(atan(static_cast<T>(2) * (q.x * q.y + q.w * q.z), q.w * q.w + q.x * q.x - q.y * q.y - q.z * q.z));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T pitch(tquat<T, P> const & q)
{
//return T(atan(T(2) * (q.y * q.z + q.w * q.x), q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z));
@ -579,13 +579,13 @@ namespace detail
return static_cast<T>(atan(y,x));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T yaw(tquat<T, P> const & q)
{
return asin(clamp(static_cast<T>(-2) * (q.x * q.z - q.w * q.y), static_cast<T>(-1), static_cast<T>(1)));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<3, 3, T, P> mat3_cast(tquat<T, P> const & q)
{
mat<3, 3, T, P> Result(T(1));
@ -613,13 +613,13 @@ namespace detail
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER mat<4, 4, T, P> mat4_cast(tquat<T, P> const & q)
{
return mat<4, 4, T, P>(mat3_cast(q));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P> quat_cast(mat<3, 3, T, P> const & m)
{
T fourXSquaredMinus1 = m[0][0] - m[1][1] - m[2][2];
@ -683,19 +683,19 @@ namespace detail
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P> quat_cast(mat<4, 4, T, P> const & m4)
{
return quat_cast(mat<3, 3, T, P>(m4));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T angle(tquat<T, P> const & x)
{
return acos(x.w) * static_cast<T>(2);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> axis(tquat<T, P> const & x)
{
T tmp1 = static_cast<T>(1) - x.w * x.w;
@ -705,7 +705,7 @@ namespace detail
return vec<3, T, P>(x.x * tmp2, x.y * tmp2, x.z * tmp2);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER tquat<T, P> angleAxis(T const & angle, vec<3, T, P> const & v)
{
tquat<T, P> Result;
@ -720,7 +720,7 @@ namespace detail
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, bool, P> lessThan(tquat<T, P> const & x, tquat<T, P> const & y)
{
vec<4, bool, P> Result;
@ -729,7 +729,7 @@ namespace detail
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, bool, P> lessThanEqual(tquat<T, P> const & x, tquat<T, P> const & y)
{
vec<4, bool, P> Result;
@ -738,7 +738,7 @@ namespace detail
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, bool, P> greaterThan(tquat<T, P> const & x, tquat<T, P> const & y)
{
vec<4, bool, P> Result;
@ -747,7 +747,7 @@ namespace detail
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, bool, P> greaterThanEqual(tquat<T, P> const & x, tquat<T, P> const & y)
{
vec<4, bool, P> Result;
@ -756,7 +756,7 @@ namespace detail
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, bool, P> equal(tquat<T, P> const& x, tquat<T, P> const& y)
{
vec<4, bool, P> Result;
@ -765,7 +765,7 @@ namespace detail
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, bool, P> notEqual(tquat<T, P> const& x, tquat<T, P> const& y)
{
vec<4, bool, P> Result;
@ -774,7 +774,7 @@ namespace detail
return Result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, bool, P> isnan(tquat<T, P> const& q)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
@ -782,7 +782,7 @@ namespace detail
return vec<4, bool, P>(isnan(q.x), isnan(q.y), isnan(q.z), isnan(q.w));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, bool, P> isinf(tquat<T, P> const& q)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isinf' only accept floating-point inputs");

22
glm/gtc/quaternion_simd.inl
View File

@ -7,7 +7,7 @@ namespace glm{
namespace detail
{
/*
template<precision P>
template<qualifier P>
struct compute_quat_mul<float, P, true>
{
static tquat<float, P> call(tquat<float, P> const& q1, tquat<float, P> const& q2)
@ -61,7 +61,7 @@ namespace detail
};
*/
template<precision P>
template<qualifier P>
struct compute_dot<tquat<float, P>, float, true>
{
static GLM_FUNC_QUALIFIER float call(tquat<float, P> const& x, tquat<float, P> const& y)
@ -70,7 +70,7 @@ namespace detail
}
};
template<precision P>
template<qualifier P>
struct compute_quat_add<float, P, true>
{
static tquat<float, P> call(tquat<float, P> const& q, tquat<float, P> const& p)
@ -82,7 +82,7 @@ namespace detail
};
# if GLM_ARCH & GLM_ARCH_AVX_BIT
template<precision P>
template<qualifier P>
struct compute_quat_add<double, P, true>
{
static tquat<double, P> call(tquat<double, P> const & a, tquat<double, P> const & b)
@ -94,7 +94,7 @@ namespace detail
};
# endif
template<precision P>
template<qualifier P>
struct compute_quat_sub<float, P, true>
{
static tquat<float, P> call(tquat<float, P> const& q, tquat<float, P> const& p)
@ -106,7 +106,7 @@ namespace detail
};
# if GLM_ARCH & GLM_ARCH_AVX_BIT
template<precision P>
template<qualifier P>
struct compute_quat_sub<double, P, true>
{
static tquat<double, P> call(tquat<double, P> const & a, tquat<double, P> const & b)
@ -118,7 +118,7 @@ namespace detail
};
# endif
template<precision P>
template<qualifier P>
struct compute_quat_mul_scalar<float, P, true>
{
static tquat<float, P> call(tquat<float, P> const& q, float s)
@ -130,7 +130,7 @@ namespace detail
};
# if GLM_ARCH & GLM_ARCH_AVX_BIT
template<precision P>
template<qualifier P>
struct compute_quat_mul_scalar<double, P, true>
{
static tquat<double, P> call(tquat<double, P> const& q, double s)
@ -142,7 +142,7 @@ namespace detail
};
# endif
template<precision P>
template<qualifier P>
struct compute_quat_div_scalar<float, P, true>
{
static tquat<float, P> call(tquat<float, P> const& q, float s)
@ -154,7 +154,7 @@ namespace detail
};
# if GLM_ARCH & GLM_ARCH_AVX_BIT
template<precision P>
template<qualifier P>
struct compute_quat_div_scalar<double, P, true>
{
static tquat<double, P> call(tquat<double, P> const& q, double s)
@ -166,7 +166,7 @@ namespace detail
};
# endif
template<precision P>
template<qualifier P>
struct compute_quat_mul_vec4<float, P, true>
{
static vec<4, float, P> call(tquat<float, P> const& q, vec<4, float, P> const& v)

4
glm/gtc/random.hpp
View File

@ -40,9 +40,9 @@ namespace glm
/// @param Min Minimum value included in the sampling
/// @param Max Maximum value included in the sampling
/// @tparam T Value type. Currently supported: float or double.
/// @tparam vecType A vertor type: tvec1, tvec2, tvec3, tvec4 or compatible
///
/// @see gtc_random
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> linearRand(vec<L, T, P> const& Min, vec<L, T, P> const& Max);
/// Generate random numbers in the interval [Min, Max], according a gaussian distribution

38
glm/gtc/random.inl
View File

@ -12,13 +12,13 @@
namespace glm{
namespace detail
{
template <length_t L, typename T, precision P>
template <length_t L, typename T, qualifier P>
struct compute_rand
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call();
};
template <precision P>
template <qualifier P>
struct compute_rand<1, uint8, P>
{
GLM_FUNC_QUALIFIER static vec<1, uint8, P> call()
@ -28,7 +28,7 @@ namespace detail
}
};
template <precision P>
template <qualifier P>
struct compute_rand<2, uint8, P>
{
GLM_FUNC_QUALIFIER static vec<2, uint8, P> call()
@ -39,7 +39,7 @@ namespace detail
}
};
template <precision P>
template <qualifier P>
struct compute_rand<3, uint8, P>
{
GLM_FUNC_QUALIFIER static vec<3, uint8, P> call()
@ -51,7 +51,7 @@ namespace detail
}
};
template <precision P>
template <qualifier P>
struct compute_rand<4, uint8, P>
{
GLM_FUNC_QUALIFIER static vec<4, uint8, P> call()
@ -64,7 +64,7 @@ namespace detail
}
};
template <length_t L, precision P>
template <length_t L, qualifier P>
struct compute_rand<L, uint16, P>
{
GLM_FUNC_QUALIFIER static vec<L, uint16, P> call()
@ -75,7 +75,7 @@ namespace detail
}
};
template <length_t L, precision P>
template <length_t L, qualifier P>
struct compute_rand<L, uint32, P>
{
GLM_FUNC_QUALIFIER static vec<L, uint32, P> call()
@ -86,7 +86,7 @@ namespace detail
}
};
template <length_t L, precision P>
template <length_t L, qualifier P>
struct compute_rand<L, uint64, P>
{
GLM_FUNC_QUALIFIER static vec<L, uint64, P> call()
@ -97,13 +97,13 @@ namespace detail
}
};
template <length_t L, typename T, precision P>
template <length_t L, typename T, qualifier P>
struct compute_linearRand
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& Min, vec<L, T, P> const& Max);
};
template<length_t L, precision P>
template<length_t L, qualifier P>
struct compute_linearRand<L, int8, P>
{
GLM_FUNC_QUALIFIER static vec<L, int8, P> call(vec<L, int8, P> const& Min, vec<L, int8, P> const& Max)
@ -112,7 +112,7 @@ namespace detail
}
};
template<length_t L, precision P>
template<length_t L, qualifier P>
struct compute_linearRand<L, uint8, P>
{
GLM_FUNC_QUALIFIER static vec<L, uint8, P> call(vec<L, uint8, P> const& Min, vec<L, uint8, P> const& Max)
@ -121,7 +121,7 @@ namespace detail
}
};
template<length_t L, precision P>
template<length_t L, qualifier P>
struct compute_linearRand<L, int16, P>
{
GLM_FUNC_QUALIFIER static vec<L, int16, P> call(vec<L, int16, P> const& Min, vec<L, int16, P> const& Max)
@ -130,7 +130,7 @@ namespace detail
}
};
template<length_t L, precision P>
template<length_t L, qualifier P>
struct compute_linearRand<L, uint16, P>
{
GLM_FUNC_QUALIFIER static vec<L, uint16, P> call(vec<L, uint16, P> const& Min, vec<L, uint16, P> const& Max)
@ -139,7 +139,7 @@ namespace detail
}
};
template<length_t L, precision P>
template<length_t L, qualifier P>
struct compute_linearRand<L, int32, P>
{
GLM_FUNC_QUALIFIER static vec<L, int32, P> call(vec<L, int32, P> const & Min, vec<L, int32, P> const& Max)
@ -148,7 +148,7 @@ namespace detail
}
};
template<length_t L, precision P>
template<length_t L, qualifier P>
struct compute_linearRand<L, uint32, P>
{
GLM_FUNC_QUALIFIER static vec<L, uint32, P> call(vec<L, uint32, P> const& Min, vec<L, uint32, P> const& Max)
@ -157,7 +157,7 @@ namespace detail
}
};
template<length_t L, precision P>
template<length_t L, qualifier P>
struct compute_linearRand<L, int64, P>
{
GLM_FUNC_QUALIFIER static vec<L, int64, P> call(vec<L, int64, P> const& Min, vec<L, int64, P> const& Max)
@ -166,7 +166,7 @@ namespace detail
}
};
template<length_t L, precision P>
template<length_t L, qualifier P>
struct compute_linearRand<L, uint64, P>
{
GLM_FUNC_QUALIFIER static vec<L, uint64, P> call(vec<L, uint64, P> const& Min, vec<L, uint64, P> const& Max)
@ -265,7 +265,7 @@ namespace detail
vec<1, genType, highp>(Max)).x;
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> linearRand(vec<L, T, P> const & Min, vec<L, T, P> const& Max)
{
return detail::compute_linearRand<L, T, P>::call(Min, Max);
@ -287,7 +287,7 @@ namespace detail
return x2 * Deviation * Deviation * sqrt((genType(-2) * log(w)) / w) + Mean;
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> gaussRand(vec<L, T, P> const& Mean, vec<L, T, P> const& Deviation)
{
return detail::functor2<L, T, P>::call(gaussRand, Mean, Deviation);

48
glm/gtc/reciprocal.inl
View File

@ -14,8 +14,8 @@ namespace glm
return genType(1) / glm::cos(angle);
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> sec(vecType<L, T, P> const & x)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> sec(vec<L, T, P> const & x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sec' only accept floating-point inputs");
return detail::functor1<L, T, T, P>::call(sec, x);
@ -29,8 +29,8 @@ namespace glm
return genType(1) / glm::sin(angle);
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> csc(vecType<L, T, P> const & x)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> csc(vec<L, T, P> const & x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'csc' only accept floating-point inputs");
return detail::functor1<L, T, T, P>::call(csc, x);
@ -46,8 +46,8 @@ namespace glm
return glm::tan(pi_over_2 - angle);
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> cot(vecType<L, T, P> const & x)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> cot(vec<L, T, P> const & x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cot' only accept floating-point inputs");
return detail::functor1<L, T, T, P>::call(cot, x);
@ -61,8 +61,8 @@ namespace glm
return acos(genType(1) / x);
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> asec(vecType<L, T, P> const & x)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> asec(vec<L, T, P> const & x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'asec' only accept floating-point inputs");
return detail::functor1<L, T, T, P>::call(asec, x);
@ -76,8 +76,8 @@ namespace glm
return asin(genType(1) / x);
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> acsc(vecType<L, T, P> const & x)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> acsc(vec<L, T, P> const & x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'acsc' only accept floating-point inputs");
return detail::functor1<L, T, T, P>::call(acsc, x);
@ -93,8 +93,8 @@ namespace glm
return pi_over_2 - atan(x);
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> acot(vecType<L, T, P> const & x)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> acot(vec<L, T, P> const & x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'acot' only accept floating-point inputs");
return detail::functor1<L, T, T, P>::call(acot, x);
@ -108,8 +108,8 @@ namespace glm
return genType(1) / glm::cosh(angle);
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> sech(vecType<L, T, P> const & x)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> sech(vec<L, T, P> const & x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sech' only accept floating-point inputs");
return detail::functor1<L, T, T, P>::call(sech, x);
@ -123,8 +123,8 @@ namespace glm
return genType(1) / glm::sinh(angle);
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> csch(vecType<L, T, P> const & x)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> csch(vec<L, T, P> const & x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'csch' only accept floating-point inputs");
return detail::functor1<L, T, T, P>::call(csch, x);
@ -138,8 +138,8 @@ namespace glm
return glm::cosh(angle) / glm::sinh(angle);
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> coth(vecType<L, T, P> const & x)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> coth(vec<L, T, P> const & x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'coth' only accept floating-point inputs");
return detail::functor1<L, T, T, P>::call(coth, x);
@ -153,8 +153,8 @@ namespace glm
return acosh(genType(1) / x);
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> asech(vecType<L, T, P> const & x)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> asech(vec<L, T, P> const & x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'asech' only accept floating-point inputs");
return detail::functor1<L, T, T, P>::call(asech, x);
@ -168,8 +168,8 @@ namespace glm
return acsch(genType(1) / x);
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> acsch(vecType<L, T, P> const & x)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> acsch(vec<L, T, P> const & x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'acsch' only accept floating-point inputs");
return detail::functor1<L, T, T, P>::call(acsch, x);
@ -183,8 +183,8 @@ namespace glm
return atanh(genType(1) / x);
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> acoth(vecType<L, T, P> const & x)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> acoth(vec<L, T, P> const & x)
{
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'acoth' only accept floating-point inputs");
return detail::functor1<L, T, T, P>::call(acoth, x);

20
glm/gtc/round.hpp
View File

@ -15,7 +15,7 @@
// Dependencies
#include "../detail/setup.hpp"
#include "../detail/precision.hpp"
#include "../detail/qualifier.hpp"
#include "../detail/_vectorize.hpp"
#include "../vector_relational.hpp"
#include "../common.hpp"
@ -39,7 +39,7 @@ namespace glm
/// Return true if the value is a power of two number.
///
/// @see gtc_round
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, bool, P> isPowerOfTwo(vec<L, T, P> const& value);
/// Return the power of two number which value is just higher the input value,
@ -53,7 +53,7 @@ namespace glm
/// round up to a power of two.
///
/// @see gtc_round
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> ceilPowerOfTwo(vec<L, T, P> const& value);
/// Return the power of two number which value is just lower the input value,
@ -67,7 +67,7 @@ namespace glm
/// round down to a power of two.
///
/// @see gtc_round
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> floorPowerOfTwo(vec<L, T, P> const& value);
/// Return the power of two number which value is the closet to the input value.
@ -79,7 +79,7 @@ namespace glm
/// Return the power of two number which value is the closet to the input value.
///
/// @see gtc_round
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> roundPowerOfTwo(vec<L, T, P> const& value);
/// Return true if the 'Value' is a multiple of 'Multiple'.
@ -91,13 +91,13 @@ namespace glm
/// Return true if the 'Value' is a multiple of 'Multiple'.
///
/// @see gtc_round
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, bool, P> isMultiple(vec<L, T, P> const& Value, T Multiple);
/// Return true if the 'Value' is a multiple of 'Multiple'.
///
/// @see gtc_round
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, bool, P> isMultiple(vec<L, T, P> const& Value, vec<L, T, P> const& Multiple);
/// Higher multiple number of Source.
@ -115,7 +115,7 @@ namespace glm
/// @param Multiple Must be a null or positive value
///
/// @see gtc_round
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> ceilMultiple(vec<L, T, P> const & Source, vec<L, T, P> const& Multiple);
/// Lower multiple number of Source.
@ -133,7 +133,7 @@ namespace glm
/// @param Multiple Must be a null or positive value
///
/// @see gtc_round
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> floorMultiple(vec<L, T, P> const& Source, vec<L, T, P> const& Multiple);
/// Lower multiple number of Source.
@ -151,7 +151,7 @@ namespace glm
/// @param Multiple Must be a null or positive value
///
/// @see gtc_round
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> roundMultiple(vec<L, T, P> const& Source, vec<L, T, P> const& Multiple);
/// @}

26
glm/gtc/round.inl
View File

@ -6,7 +6,7 @@
namespace glm{
namespace detail
{
template<length_t L, typename T, precision P, bool compute = false>
template<length_t L, typename T, qualifier P, bool compute = false>
struct compute_ceilShift
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& v, T)
@ -15,7 +15,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
struct compute_ceilShift<L, T, P, true>
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& v, T Shift)
@ -24,7 +24,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P, bool isSigned = true>
template<length_t L, typename T, qualifier P, bool isSigned = true>
struct compute_ceilPowerOfTwo
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& x)
@ -46,7 +46,7 @@ namespace detail
}
};
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
struct compute_ceilPowerOfTwo<L, T, P, false>
{
GLM_FUNC_QUALIFIER static vec<L, T, P> call(vec<L, T, P> const& x)
@ -219,7 +219,7 @@ namespace detail
return !(Result & (Result - 1));
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, bool, P> isPowerOfTwo(vec<L, T, P> const & Value)
{
vec<L, T, P> const Result(abs(Value));
@ -235,7 +235,7 @@ namespace detail
return detail::compute_ceilPowerOfTwo<1, genType, defaultp, std::numeric_limits<genType>::is_signed>::call(vec<1, genType, defaultp>(value)).x;
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> ceilPowerOfTwo(vec<L, T, P> const& v)
{
return detail::compute_ceilPowerOfTwo<L, T, P, std::numeric_limits<T>::is_signed>::call(v);
@ -250,7 +250,7 @@ namespace detail
return isPowerOfTwo(value) ? value : static_cast<genType>(1) << findMSB(value);
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> floorPowerOfTwo(vec<L, T, P> const & v)
{
return detail::functor1<L, T, T, P>::call(floorPowerOfTwo, v);
@ -270,7 +270,7 @@ namespace detail
return (next - value) < (value - prev) ? next : prev;
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> roundPowerOfTwo(vec<L, T, P> const & v)
{
return detail::functor1<L, T, T, P>::call(roundPowerOfTwo, v);
@ -285,13 +285,13 @@ namespace detail
return isMultiple(vec<1, genType>(Value), vec<1, genType>(Multiple)).x;
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, bool, P> isMultiple(vec<L, T, P> const & Value, T Multiple)
{
return (Value % Multiple) == vec<L, T, P>(0);
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, bool, P> isMultiple(vec<L, T, P> const& Value, vec<L, T, P> const& Multiple)
{
return (Value % Multiple) == vec<L, T, P>(0);
@ -306,7 +306,7 @@ namespace detail
return detail::compute_ceilMultiple<std::numeric_limits<genType>::is_iec559, std::numeric_limits<genType>::is_signed>::call(Source, Multiple);
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> ceilMultiple(vec<L, T, P> const& Source, vec<L, T, P> const& Multiple)
{
return detail::functor2<L, T, P>::call(ceilMultiple, Source, Multiple);
@ -321,7 +321,7 @@ namespace detail
return detail::compute_floorMultiple<std::numeric_limits<genType>::is_iec559, std::numeric_limits<genType>::is_signed>::call(Source, Multiple);
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> floorMultiple(vec<L, T, P> const& Source, vec<L, T, P> const& Multiple)
{
return detail::functor2<L, T, P>::call(floorMultiple, Source, Multiple);
@ -336,7 +336,7 @@ namespace detail
return detail::compute_roundMultiple<std::numeric_limits<genType>::is_iec559, std::numeric_limits<genType>::is_signed>::call(Source, Multiple);
}
template<length_t L, typename T, precision P>
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> roundMultiple(vec<L, T, P> const& Source, vec<L, T, P> const& Multiple)
{
return detail::functor2<L, T, P>::call(roundMultiple, Source, Multiple);

152
glm/gtc/type_aligned.hpp
View File

@ -64,170 +64,170 @@ namespace glm
// -- *vec2 --
/// 2 components vector of high single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of high single-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<2, float, aligned_highp> aligned_highp_vec2;
/// 2 components vector of medium single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of medium single-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<2, float, aligned_mediump> aligned_mediump_vec2;
/// 2 components vector of low single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of low single-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<2, float, aligned_lowp> aligned_lowp_vec2;
/// 2 components vector of high double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of high double-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<2, double, aligned_highp> aligned_highp_dvec2;
/// 2 components vector of medium double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of medium double-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<2, double, aligned_mediump> aligned_mediump_dvec2;
/// 2 components vector of low double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of low double-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<2, double, aligned_lowp> aligned_lowp_dvec2;
/// 2 components vector of high precision signed integer numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of high qualifier signed integer numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<2, int, aligned_highp> aligned_highp_ivec2;
/// 2 components vector of medium precision signed integer numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of medium qualifier signed integer numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<2, int, aligned_mediump> aligned_mediump_ivec2;
/// 2 components vector of low precision signed integer numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of low qualifier signed integer numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<2, int, aligned_lowp> aligned_lowp_ivec2;
/// 2 components vector of high precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of high qualifier unsigned integer numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<2, uint, aligned_highp> aligned_highp_uvec2;
/// 2 components vector of medium precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of medium qualifier unsigned integer numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<2, uint, aligned_mediump> aligned_mediump_uvec2;
/// 2 components vector of low precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of low qualifier unsigned integer numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<2, uint, aligned_lowp> aligned_lowp_uvec2;
/// 2 components vector of high precision bool numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of high qualifier bool numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<2, bool, aligned_highp> aligned_highp_bvec2;
/// 2 components vector of medium precision bool numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of medium qualifier bool numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<2, bool, aligned_mediump> aligned_mediump_bvec2;
/// 2 components vector of low precision bool numbers.
/// There is no guarantee on the actual precision.
/// 2 components vector of low qualifier bool numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<2, bool, aligned_lowp> aligned_lowp_bvec2;
// -- *vec3 --
/// 3 components vector of high single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of high single-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<3, float, aligned_highp> aligned_highp_vec3;
/// 3 components vector of medium single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of medium single-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<3, float, aligned_mediump> aligned_mediump_vec3;
/// 3 components vector of low single-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of low single-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<3, float, aligned_lowp> aligned_lowp_vec3;
/// 3 components vector of high double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of high double-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<3, double, aligned_highp> aligned_highp_dvec3;
/// 3 components vector of medium double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of medium double-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<3, double, aligned_mediump> aligned_mediump_dvec3;
/// 3 components vector of low double-precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of low double-qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<3, double, aligned_lowp> aligned_lowp_dvec3;
/// 3 components vector of high precision signed integer numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of high qualifier signed integer numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<3, int, aligned_highp> aligned_highp_ivec3;
/// 3 components vector of medium precision signed integer numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of medium qualifier signed integer numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<3, int, aligned_mediump> aligned_mediump_ivec3;
/// 3 components vector of low precision signed integer numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of low qualifier signed integer numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<3, int, aligned_lowp> aligned_lowp_ivec3;
/// 3 components vector of high precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of high qualifier unsigned integer numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<3, uint, aligned_highp> aligned_highp_uvec3;
/// 3 components vector of medium precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of medium qualifier unsigned integer numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<3, uint, aligned_mediump> aligned_mediump_uvec3;
/// 3 components vector of low precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
/// 3 components vector of low qualifier unsigned integer numbers.
/// There is no guarantee on the actual qualifier.
typedef vec<3, uint, aligned_lowp> aligned_lowp_uvec3;
/// 3 components vector of high precision bool numbers.
/// 3 components vector of high qualifier bool numbers.
typedef vec<3, bool, aligned_highp> aligned_highp_bvec3;
/// 3 components vector of medium precision bool numbers.
/// 3 components vector of medium qualifier bool numbers.
typedef vec<3, bool, aligned_mediump> aligned_mediump_bvec3;
/// 3 components vector of low precision bool numbers.
/// 3 components vector of low qualifier bool numbers.
typedef vec<3, bool, aligned_lowp> aligned_lowp_bvec3;
// -- *vec4 --
/// 4 components vector of high single-precision floating-point numbers.
/// 4 components vector of high single-qualifier floating-point numbers.
typedef vec<4, float, aligned_highp> aligned_highp_vec4;
/// 4 components vector of medium single-precision floating-point numbers.
/// 4 components vector of medium single-qualifier floating-point numbers.
typedef vec<4, float, aligned_mediump> aligned_mediump_vec4;
/// 4 components vector of low single-precision floating-point numbers.
/// 4 components vector of low single-qualifier floating-point numbers.
typedef vec<4, float, aligned_lowp> aligned_lowp_vec4;
/// 4 components vector of high double-precision floating-point numbers.
/// 4 components vector of high double-qualifier floating-point numbers.
typedef vec<4, double, aligned_highp> aligned_highp_dvec4;
/// 4 components vector of medium double-precision floating-point numbers.
/// 4 components vector of medium double-qualifier floating-point numbers.
typedef vec<4, double, aligned_mediump> aligned_mediump_dvec4;
/// 4 components vector of low double-precision floating-point numbers.
/// 4 components vector of low double-qualifier floating-point numbers.
typedef vec<4, double, aligned_lowp> aligned_lowp_dvec4;
/// 4 components vector of high precision signed integer numbers.
/// 4 components vector of high qualifier signed integer numbers.
typedef vec<4, int, aligned_highp> aligned_highp_ivec4;
/// 4 components vector of medium precision signed integer numbers.
/// 4 components vector of medium qualifier signed integer numbers.
typedef vec<4, int, aligned_mediump> aligned_mediump_ivec4;
/// 4 components vector of low precision signed integer numbers.
/// 4 components vector of low qualifier signed integer numbers.
typedef vec<4, int, aligned_lowp> aligned_lowp_ivec4;
/// 4 components vector of high precision unsigned integer numbers.
/// 4 components vector of high qualifier unsigned integer numbers.
typedef vec<4, uint, aligned_highp> aligned_highp_uvec4;
/// 4 components vector of medium precision unsigned integer numbers.
/// 4 components vector of medium qualifier unsigned integer numbers.
typedef vec<4, uint, aligned_mediump> aligned_mediump_uvec4;
/// 4 components vector of low precision unsigned integer numbers.
/// 4 components vector of low qualifier unsigned integer numbers.
typedef vec<4, uint, aligned_lowp> aligned_lowp_uvec4;
/// 4 components vector of high precision bool numbers.
/// 4 components vector of high qualifier bool numbers.
typedef vec<4, bool, aligned_highp> aligned_highp_bvec4;
/// 4 components vector of medium precision bool numbers.
/// 4 components vector of medium qualifier bool numbers.
typedef vec<4, bool, aligned_mediump> aligned_mediump_bvec4;
/// 4 components vector of low precision bool numbers.
/// 4 components vector of low qualifier bool numbers.
typedef vec<4, bool, aligned_lowp> aligned_lowp_bvec4;
// -- default --
@ -267,16 +267,16 @@ namespace glm
typedef aligned_mediump_dvec3 aligned_dvec3;
typedef aligned_mediump_dvec4 aligned_dvec4;
#else //defined(GLM_PRECISION_HIGHP_DOUBLE)
/// 1 component vector of double-precision floating-point numbers.
/// 1 component vector of double-qualifier floating-point numbers.
typedef aligned_highp_dvec1 aligned_dvec1;
/// 2 components vector of double-precision floating-point numbers.
/// 2 components vector of double-qualifier floating-point numbers.
typedef aligned_highp_dvec2 aligned_dvec2;
/// 3 components vector of double-precision floating-point numbers.
/// 3 components vector of double-qualifier floating-point numbers.
typedef aligned_highp_dvec3 aligned_dvec3;
/// 4 components vector of double-precision floating-point numbers.
/// 4 components vector of double-qualifier floating-point numbers.
typedef aligned_highp_dvec4 aligned_dvec4;
#endif//GLM_PRECISION

326
glm/gtc/type_precision.hpp
View File

@ -7,9 +7,9 @@
/// @defgroup gtc_type_precision GLM_GTC_type_precision
/// @ingroup gtc
///
/// @brief Defines specific C++-based precision types.
/// @brief Defines specific C++-based qualifier types.
///
/// @ref core_precision defines types based on GLSL's precision qualifiers. This
/// @ref core_precision defines types based on GLSL's qualifier qualifiers. This
/// extension defines types based on explicitly-sized C++ data types.
///
/// <glm/gtc/type_precision.hpp> need to be included to use these functionalities.
@ -44,123 +44,123 @@ namespace glm
/// @addtogroup gtc_type_precision
/// @{
/// Low precision 8 bit signed integer type.
/// Low qualifier 8 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int8 lowp_int8;
/// Low precision 16 bit signed integer type.
/// Low qualifier 16 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int16 lowp_int16;
/// Low precision 32 bit signed integer type.
/// Low qualifier 32 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int32 lowp_int32;
/// Low precision 64 bit signed integer type.
/// Low qualifier 64 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int64 lowp_int64;
/// Low precision 8 bit signed integer type.
/// Low qualifier 8 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int8 lowp_int8_t;
/// Low precision 16 bit signed integer type.
/// Low qualifier 16 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int16 lowp_int16_t;
/// Low precision 32 bit signed integer type.
/// Low qualifier 32 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int32 lowp_int32_t;
/// Low precision 64 bit signed integer type.
/// Low qualifier 64 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int64 lowp_int64_t;
/// Low precision 8 bit signed integer type.
/// Low qualifier 8 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int8 lowp_i8;
/// Low precision 16 bit signed integer type.
/// Low qualifier 16 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int16 lowp_i16;
/// Low precision 32 bit signed integer type.
/// Low qualifier 32 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int32 lowp_i32;
/// Low precision 64 bit signed integer type.
/// Low qualifier 64 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int64 lowp_i64;
/// Medium precision 8 bit signed integer type.
/// Medium qualifier 8 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int8 mediump_int8;
/// Medium precision 16 bit signed integer type.
/// Medium qualifier 16 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int16 mediump_int16;
/// Medium precision 32 bit signed integer type.
/// Medium qualifier 32 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int32 mediump_int32;
/// Medium precision 64 bit signed integer type.
/// Medium qualifier 64 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int64 mediump_int64;
/// Medium precision 8 bit signed integer type.
/// Medium qualifier 8 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int8 mediump_int8_t;
/// Medium precision 16 bit signed integer type.
/// Medium qualifier 16 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int16 mediump_int16_t;
/// Medium precision 32 bit signed integer type.
/// Medium qualifier 32 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int32 mediump_int32_t;
/// Medium precision 64 bit signed integer type.
/// Medium qualifier 64 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int64 mediump_int64_t;
/// Medium precision 8 bit signed integer type.
/// Medium qualifier 8 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int8 mediump_i8;
/// Medium precision 16 bit signed integer type.
/// Medium qualifier 16 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int16 mediump_i16;
/// Medium precision 32 bit signed integer type.
/// Medium qualifier 32 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int32 mediump_i32;
/// Medium precision 64 bit signed integer type.
/// Medium qualifier 64 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int64 mediump_i64;
/// High precision 8 bit signed integer type.
/// High qualifier 8 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int8 highp_int8;
/// High precision 16 bit signed integer type.
/// High qualifier 16 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int16 highp_int16;
/// High precision 32 bit signed integer type.
/// High qualifier 32 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int32 highp_int32;
/// High precision 64 bit signed integer type.
/// High qualifier 64 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int64 highp_int64;
/// High precision 8 bit signed integer type.
/// High qualifier 8 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int8 highp_int8_t;
/// High precision 16 bit signed integer type.
/// High qualifier 16 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int16 highp_int16_t;
@ -168,23 +168,23 @@ namespace glm
/// @see gtc_type_precision
typedef detail::int32 highp_int32_t;
/// High precision 64 bit signed integer type.
/// High qualifier 64 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int64 highp_int64_t;
/// High precision 8 bit signed integer type.
/// High qualifier 8 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int8 highp_i8;
/// High precision 16 bit signed integer type.
/// High qualifier 16 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int16 highp_i16;
/// High precision 32 bit signed integer type.
/// High qualifier 32 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int32 highp_i32;
/// High precision 64 bit signed integer type.
/// High qualifier 64 bit signed integer type.
/// @see gtc_type_precision
typedef detail::int64 highp_i64;
@ -316,163 +316,163 @@ namespace glm
/////////////////////////////
// Unsigned int vector types
/// Low precision 8 bit unsigned integer type.
/// Low qualifier 8 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint8 lowp_uint8;
/// Low precision 16 bit unsigned integer type.
/// Low qualifier 16 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint16 lowp_uint16;
/// Low precision 32 bit unsigned integer type.
/// Low qualifier 32 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint32 lowp_uint32;
/// Low precision 64 bit unsigned integer type.
/// Low qualifier 64 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint64 lowp_uint64;
/// Low precision 8 bit unsigned integer type.
/// Low qualifier 8 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint8 lowp_uint8_t;
/// Low precision 16 bit unsigned integer type.
/// Low qualifier 16 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint16 lowp_uint16_t;
/// Low precision 32 bit unsigned integer type.
/// Low qualifier 32 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint32 lowp_uint32_t;
/// Low precision 64 bit unsigned integer type.
/// Low qualifier 64 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint64 lowp_uint64_t;
/// Low precision 8 bit unsigned integer type.
/// Low qualifier 8 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint8 lowp_u8;
/// Low precision 16 bit unsigned integer type.
/// Low qualifier 16 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint16 lowp_u16;
/// Low precision 32 bit unsigned integer type.
/// Low qualifier 32 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint32 lowp_u32;
/// Low precision 64 bit unsigned integer type.
/// Low qualifier 64 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint64 lowp_u64;
/// Medium precision 8 bit unsigned integer type.
/// Medium qualifier 8 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint8 mediump_uint8;
/// Medium precision 16 bit unsigned integer type.
/// Medium qualifier 16 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint16 mediump_uint16;
/// Medium precision 32 bit unsigned integer type.
/// Medium qualifier 32 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint32 mediump_uint32;
/// Medium precision 64 bit unsigned integer type.
/// Medium qualifier 64 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint64 mediump_uint64;
/// Medium precision 8 bit unsigned integer type.
/// Medium qualifier 8 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint8 mediump_uint8_t;
/// Medium precision 16 bit unsigned integer type.
/// Medium qualifier 16 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint16 mediump_uint16_t;
/// Medium precision 32 bit unsigned integer type.
/// Medium qualifier 32 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint32 mediump_uint32_t;
/// Medium precision 64 bit unsigned integer type.
/// Medium qualifier 64 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint64 mediump_uint64_t;
/// Medium precision 8 bit unsigned integer type.
/// Medium qualifier 8 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint8 mediump_u8;
/// Medium precision 16 bit unsigned integer type.
/// Medium qualifier 16 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint16 mediump_u16;
/// Medium precision 32 bit unsigned integer type.
/// Medium qualifier 32 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint32 mediump_u32;
/// Medium precision 64 bit unsigned integer type.
/// Medium qualifier 64 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint64 mediump_u64;
/// High precision 8 bit unsigned integer type.
/// High qualifier 8 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint8 highp_uint8;
/// High precision 16 bit unsigned integer type.
/// High qualifier 16 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint16 highp_uint16;
/// High precision 32 bit unsigned integer type.
/// High qualifier 32 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint32 highp_uint32;
/// High precision 64 bit unsigned integer type.
/// High qualifier 64 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint64 highp_uint64;
/// High precision 8 bit unsigned integer type.
/// High qualifier 8 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint8 highp_uint8_t;
/// High precision 16 bit unsigned integer type.
/// High qualifier 16 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint16 highp_uint16_t;
/// High precision 32 bit unsigned integer type.
/// High qualifier 32 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint32 highp_uint32_t;
/// High precision 64 bit unsigned integer type.
/// High qualifier 64 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint64 highp_uint64_t;
/// High precision 8 bit unsigned integer type.
/// High qualifier 8 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint8 highp_u8;
/// High precision 16 bit unsigned integer type.
/// High qualifier 16 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint16 highp_u16;
/// High precision 32 bit unsigned integer type.
/// High qualifier 32 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint32 highp_u32;
/// High precision 64 bit unsigned integer type.
/// High qualifier 64 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint64 highp_u64;
/// Default precision 8 bit unsigned integer type.
/// Default qualifier 8 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint8 uint8;
/// Default precision 16 bit unsigned integer type.
/// Default qualifier 16 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint16 uint16;
/// Default precision 32 bit unsigned integer type.
/// Default qualifier 32 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint32 uint32;
/// Default precision 64 bit unsigned integer type.
/// Default qualifier 64 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint64 uint64;
@ -482,105 +482,105 @@ namespace glm
using std::uint32_t;
using std::uint64_t;
#else
/// Default precision 8 bit unsigned integer type.
/// Default qualifier 8 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint8 uint8_t;
/// Default precision 16 bit unsigned integer type.
/// Default qualifier 16 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint16 uint16_t;
/// Default precision 32 bit unsigned integer type.
/// Default qualifier 32 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint32 uint32_t;
/// Default precision 64 bit unsigned integer type.
/// Default qualifier 64 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint64 uint64_t;
#endif
/// Default precision 8 bit unsigned integer type.
/// Default qualifier 8 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint8 u8;
/// Default precision 16 bit unsigned integer type.
/// Default qualifier 16 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint16 u16;
/// Default precision 32 bit unsigned integer type.
/// Default qualifier 32 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint32 u32;
/// Default precision 64 bit unsigned integer type.
/// Default qualifier 64 bit unsigned integer type.
/// @see gtc_type_precision
typedef detail::uint64 u64;
/// Default precision 8 bit unsigned integer scalar type.
/// Default qualifier 8 bit unsigned integer scalar type.
/// @see gtc_type_precision
typedef vec<1, u8, defaultp> u8vec1;
/// Default precision 8 bit unsigned integer vector of 2 components type.
/// Default qualifier 8 bit unsigned integer vector of 2 components type.
/// @see gtc_type_precision
typedef vec<2, u8, defaultp> u8vec2;
/// Default precision 8 bit unsigned integer vector of 3 components type.
/// Default qualifier 8 bit unsigned integer vector of 3 components type.
/// @see gtc_type_precision
typedef vec<3, u8, defaultp> u8vec3;
/// Default precision 8 bit unsigned integer vector of 4 components type.
/// Default qualifier 8 bit unsigned integer vector of 4 components type.
/// @see gtc_type_precision
typedef vec<4, u8, defaultp> u8vec4;
/// Default precision 16 bit unsigned integer scalar type.
/// Default qualifier 16 bit unsigned integer scalar type.
/// @see gtc_type_precision
typedef vec<1, u16, defaultp> u16vec1;
/// Default precision 16 bit unsigned integer vector of 2 components type.
/// Default qualifier 16 bit unsigned integer vector of 2 components type.
/// @see gtc_type_precision
typedef vec<2, u16, defaultp> u16vec2;
/// Default precision 16 bit unsigned integer vector of 3 components type.
/// Default qualifier 16 bit unsigned integer vector of 3 components type.
/// @see gtc_type_precision
typedef vec<3, u16, defaultp> u16vec3;
/// Default precision 16 bit unsigned integer vector of 4 components type.
/// Default qualifier 16 bit unsigned integer vector of 4 components type.
/// @see gtc_type_precision
typedef vec<4, u16, defaultp> u16vec4;
/// Default precision 32 bit unsigned integer scalar type.
/// Default qualifier 32 bit unsigned integer scalar type.
/// @see gtc_type_precision
typedef vec<1, u32, defaultp> u32vec1;
/// Default precision 32 bit unsigned integer vector of 2 components type.
/// Default qualifier 32 bit unsigned integer vector of 2 components type.
/// @see gtc_type_precision
typedef vec<2, u32, defaultp> u32vec2;
/// Default precision 32 bit unsigned integer vector of 3 components type.
/// Default qualifier 32 bit unsigned integer vector of 3 components type.
/// @see gtc_type_precision
typedef vec<3, u32, defaultp> u32vec3;
/// Default precision 32 bit unsigned integer vector of 4 components type.
/// Default qualifier 32 bit unsigned integer vector of 4 components type.
/// @see gtc_type_precision
typedef vec<4, u32, defaultp> u32vec4;
/// Default precision 64 bit unsigned integer scalar type.
/// Default qualifier 64 bit unsigned integer scalar type.
/// @see gtc_type_precision
typedef vec<1, u64, defaultp> u64vec1;
/// Default precision 64 bit unsigned integer vector of 2 components type.
/// Default qualifier 64 bit unsigned integer vector of 2 components type.
/// @see gtc_type_precision
typedef vec<2, u64, defaultp> u64vec2;
/// Default precision 64 bit unsigned integer vector of 3 components type.
/// Default qualifier 64 bit unsigned integer vector of 3 components type.
/// @see gtc_type_precision
typedef vec<3, u64, defaultp> u64vec3;
/// Default precision 64 bit unsigned integer vector of 4 components type.
/// Default qualifier 64 bit unsigned integer vector of 4 components type.
/// @see gtc_type_precision
typedef vec<4, u64, defaultp> u64vec4;
@ -588,80 +588,80 @@ namespace glm
//////////////////////
// Float vector types
/// 32 bit single-precision floating-point scalar.
/// 32 bit single-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float32 float32;
/// 64 bit double-precision floating-point scalar.
/// 64 bit double-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float64 float64;
/// 32 bit single-precision floating-point scalar.
/// 32 bit single-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float32 float32_t;
/// 64 bit double-precision floating-point scalar.
/// 64 bit double-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef detail::float64 float64_t;
/// 32 bit single-precision floating-point scalar.
/// 32 bit single-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef float32 f32;
/// 64 bit double-precision floating-point scalar.
/// 64 bit double-qualifier floating-point scalar.
/// @see gtc_type_precision
typedef float64 f64;
/// Single-precision floating-point vector of 1 component.
/// Single-qualifier floating-point vector of 1 component.
/// @see gtc_type_precision
typedef vec<1, float, defaultp> fvec1;
/// Single-precision floating-point vector of 2 components.
/// Single-qualifier floating-point vector of 2 components.
/// @see gtc_type_precision
typedef vec<2, float, defaultp> fvec2;
/// Single-precision floating-point vector of 3 components.
/// Single-qualifier floating-point vector of 3 components.
/// @see gtc_type_precision
typedef vec<3, float, defaultp> fvec3;
/// Single-precision floating-point vector of 4 components.
/// Single-qualifier floating-point vector of 4 components.
/// @see gtc_type_precision
typedef vec<4, float, defaultp> fvec4;
/// Single-precision floating-point vector of 1 component.
/// Single-qualifier floating-point vector of 1 component.
/// @see gtc_type_precision
typedef vec<1, f32, defaultp> f32vec1;
/// Single-precision floating-point vector of 2 components.
/// Single-qualifier floating-point vector of 2 components.
/// @see gtc_type_precision
typedef vec<2, f32, defaultp> f32vec2;
/// Single-precision floating-point vector of 3 components.
/// Single-qualifier floating-point vector of 3 components.
/// @see gtc_type_precision
typedef vec<3, f32, defaultp> f32vec3;
/// Single-precision floating-point vector of 4 components.
/// Single-qualifier floating-point vector of 4 components.
/// @see gtc_type_precision
typedef vec<4, f32, defaultp> f32vec4;
/// Double-precision floating-point vector of 1 component.
/// Double-qualifier floating-point vector of 1 component.
/// @see gtc_type_precision
typedef vec<1, f64, defaultp> f64vec1;
/// Double-precision floating-point vector of 2 components.
/// Double-qualifier floating-point vector of 2 components.
/// @see gtc_type_precision
typedef vec<2, f64, defaultp> f64vec2;
/// Double-precision floating-point vector of 3 components.
/// Double-qualifier floating-point vector of 3 components.
/// @see gtc_type_precision
typedef vec<3, f64, defaultp> f64vec3;
/// Double-precision floating-point vector of 4 components.
/// Double-qualifier floating-point vector of 4 components.
/// @see gtc_type_precision
typedef vec<4, f64, defaultp> f64vec4;
@ -669,176 +669,176 @@ namespace glm
//////////////////////
// Float matrix types
/// Single-precision floating-point 1x1 matrix.
/// Single-qualifier floating-point 1x1 matrix.
/// @see gtc_type_precision
//typedef detail::tmat1x1<f32> fmat1;
/// Single-precision floating-point 2x2 matrix.
/// Single-qualifier floating-point 2x2 matrix.
/// @see gtc_type_precision
typedef mat<2, 2, f32, defaultp> fmat2;
/// Single-precision floating-point 3x3 matrix.
/// Single-qualifier floating-point 3x3 matrix.
/// @see gtc_type_precision
typedef mat<3, 3, f32, defaultp> fmat3;
/// Single-precision floating-point 4x4 matrix.
/// Single-qualifier floating-point 4x4 matrix.
/// @see gtc_type_precision
typedef mat<4, 4, f32, defaultp> fmat4;
/// Single-precision floating-point 1x1 matrix.
/// Single-qualifier floating-point 1x1 matrix.
/// @see gtc_type_precision
//typedef f32 fmat1x1;
/// Single-precision floating-point 2x2 matrix.
/// Single-qualifier floating-point 2x2 matrix.
/// @see gtc_type_precision
typedef mat<2, 2, f32, defaultp> fmat2x2;
/// Single-precision floating-point 2x3 matrix.
/// Single-qualifier floating-point 2x3 matrix.
/// @see gtc_type_precision
typedef mat<2, 3, f32, defaultp> fmat2x3;
/// Single-precision floating-point 2x4 matrix.
/// Single-qualifier floating-point 2x4 matrix.
/// @see gtc_type_precision
typedef mat<2, 4, f32, defaultp> fmat2x4;
/// Single-precision floating-point 3x2 matrix.
/// Single-qualifier floating-point 3x2 matrix.
/// @see gtc_type_precision
typedef mat<3, 2, f32, defaultp> fmat3x2;
/// Single-precision floating-point 3x3 matrix.
/// Single-qualifier floating-point 3x3 matrix.
/// @see gtc_type_precision
typedef mat<3, 3, f32, defaultp> fmat3x3;
/// Single-precision floating-point 3x4 matrix.
/// Single-qualifier floating-point 3x4 matrix.
/// @see gtc_type_precision
typedef mat<3, 4, f32, defaultp> fmat3x4;
/// Single-precision floating-point 4x2 matrix.
/// Single-qualifier floating-point 4x2 matrix.
/// @see gtc_type_precision
typedef mat<4, 2, f32, defaultp> fmat4x2;
/// Single-precision floating-point 4x3 matrix.
/// Single-qualifier floating-point 4x3 matrix.
/// @see gtc_type_precision
typedef mat<4, 3, f32, defaultp> fmat4x3;
/// Single-precision floating-point 4x4 matrix.
/// Single-qualifier floating-point 4x4 matrix.
/// @see gtc_type_precision
typedef mat<4, 4, f32, defaultp> fmat4x4;
/// Single-precision floating-point 1x1 matrix.
/// Single-qualifier floating-point 1x1 matrix.
/// @see gtc_type_precision
//typedef detail::tmat1x1<f32, defaultp> f32mat1;
/// Single-precision floating-point 2x2 matrix.
/// Single-qualifier floating-point 2x2 matrix.
/// @see gtc_type_precision
typedef mat<2, 2, f32, defaultp> f32mat2;
/// Single-precision floating-point 3x3 matrix.
/// Single-qualifier floating-point 3x3 matrix.
/// @see gtc_type_precision
typedef mat<3, 3, f32, defaultp> f32mat3;
/// Single-precision floating-point 4x4 matrix.
/// Single-qualifier floating-point 4x4 matrix.
/// @see gtc_type_precision
typedef mat<4, 4, f32, defaultp> f32mat4;
/// Single-precision floating-point 1x1 matrix.
/// Single-qualifier floating-point 1x1 matrix.
/// @see gtc_type_precision
//typedef f32 f32mat1x1;
/// Single-precision floating-point 2x2 matrix.
/// Single-qualifier floating-point 2x2 matrix.
/// @see gtc_type_precision
typedef mat<2, 2, f32, defaultp> f32mat2x2;
/// Single-precision floating-point 2x3 matrix.
/// Single-qualifier floating-point 2x3 matrix.
/// @see gtc_type_precision
typedef mat<2, 3, f32, defaultp> f32mat2x3;
/// Single-precision floating-point 2x4 matrix.
/// Single-qualifier floating-point 2x4 matrix.
/// @see gtc_type_precision
typedef mat<2, 4, f32, defaultp> f32mat2x4;
/// Single-precision floating-point 3x2 matrix.
/// Single-qualifier floating-point 3x2 matrix.
/// @see gtc_type_precision
typedef mat<3, 2, f32, defaultp> f32mat3x2;
/// Single-precision floating-point 3x3 matrix.
/// Single-qualifier floating-point 3x3 matrix.
/// @see gtc_type_precision
typedef mat<3, 3, f32, defaultp> f32mat3x3;
/// Single-precision floating-point 3x4 matrix.
/// Single-qualifier floating-point 3x4 matrix.
/// @see gtc_type_precision
typedef mat<3, 4, f32, defaultp> f32mat3x4;
/// Single-precision floating-point 4x2 matrix.
/// Single-qualifier floating-point 4x2 matrix.
/// @see gtc_type_precision
typedef mat<4, 2, f32, defaultp> f32mat4x2;
/// Single-precision floating-point 4x3 matrix.
/// Single-qualifier floating-point 4x3 matrix.
/// @see gtc_type_precision
typedef mat<4, 3, f32, defaultp> f32mat4x3;
/// Single-precision floating-point 4x4 matrix.
/// Single-qualifier floating-point 4x4 matrix.
/// @see gtc_type_precision
typedef mat<4, 4, f32, defaultp> f32mat4x4;
/// Double-precision floating-point 1x1 matrix.
/// Double-qualifier floating-point 1x1 matrix.
/// @see gtc_type_precision
//typedef detail::tmat1x1<f64, defaultp> f64mat1;
/// Double-precision floating-point 2x2 matrix.
/// Double-qualifier floating-point 2x2 matrix.
/// @see gtc_type_precision
typedef mat<2, 2, f64, defaultp> f64mat2;
/// Double-precision floating-point 3x3 matrix.
/// Double-qualifier floating-point 3x3 matrix.
/// @see gtc_type_precision
typedef mat<3, 3, f64, defaultp> f64mat3;
/// Double-precision floating-point 4x4 matrix.
/// Double-qualifier floating-point 4x4 matrix.
/// @see gtc_type_precision
typedef mat<4, 4, f64, defaultp> f64mat4;
/// Double-precision floating-point 1x1 matrix.
/// Double-qualifier floating-point 1x1 matrix.
/// @see gtc_type_precision
//typedef f64 f64mat1x1;
/// Double-precision floating-point 2x2 matrix.
/// Double-qualifier floating-point 2x2 matrix.
/// @see gtc_type_precision
typedef mat<2, 2, f64, defaultp> f64mat2x2;
/// Double-precision floating-point 2x3 matrix.
/// Double-qualifier floating-point 2x3 matrix.
/// @see gtc_type_precision
typedef mat<2, 3, f64, defaultp> f64mat2x3;
/// Double-precision floating-point 2x4 matrix.
/// Double-qualifier floating-point 2x4 matrix.
/// @see gtc_type_precision
typedef mat<2, 4, f64, defaultp> f64mat2x4;
/// Double-precision floating-point 3x2 matrix.
/// Double-qualifier floating-point 3x2 matrix.
/// @see gtc_type_precision
typedef mat<3, 2, f64, defaultp> f64mat3x2;
/// Double-precision floating-point 3x3 matrix.
/// Double-qualifier floating-point 3x3 matrix.
/// @see gtc_type_precision
typedef mat<3, 3, f64, defaultp> f64mat3x3;
/// Double-precision floating-point 3x4 matrix.
/// Double-qualifier floating-point 3x4 matrix.
/// @see gtc_type_precision
typedef mat<3, 4, f64, defaultp> f64mat3x4;
/// Double-precision floating-point 4x2 matrix.
/// Double-qualifier floating-point 4x2 matrix.
/// @see gtc_type_precision
typedef mat<4, 2, f64, defaultp> f64mat4x2;
/// Double-precision floating-point 4x3 matrix.
/// Double-qualifier floating-point 4x3 matrix.
/// @see gtc_type_precision
typedef mat<4, 3, f64, defaultp> f64mat4x3;
/// Double-precision floating-point 4x4 matrix.
/// Double-qualifier floating-point 4x4 matrix.
/// @see gtc_type_precision
typedef mat<4, 4, f64, defaultp> f64mat4x4;
@ -846,11 +846,11 @@ namespace glm
//////////////////////////
// Quaternion types
/// Single-precision floating-point quaternion.
/// Single-qualifier floating-point quaternion.
/// @see gtc_type_precision
typedef tquat<f32, defaultp> f32quat;
/// Double-precision floating-point quaternion.
/// Double-qualifier floating-point quaternion.
/// @see gtc_type_precision
typedef tquat<f64, defaultp> f64quat;

52
glm/gtc/type_ptr.inl
View File

@ -10,7 +10,7 @@ namespace glm
/// Return the constant address to the data of the vector input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T const* value_ptr(vec<2, T, P> const& v)
{
return &(v.x);
@ -18,7 +18,7 @@ namespace glm
//! Return the address to the data of the vector input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T* value_ptr(vec<2, T, P>& v)
{
return &(v.x);
@ -26,7 +26,7 @@ namespace glm
/// Return the constant address to the data of the vector input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T const * value_ptr(vec<3, T, P> const& v)
{
return &(v.x);
@ -34,7 +34,7 @@ namespace glm
//! Return the address to the data of the vector input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T* value_ptr(vec<3, T, P>& v)
{
return &(v.x);
@ -42,7 +42,7 @@ namespace glm
/// Return the constant address to the data of the vector input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T const* value_ptr(vec<4, T, P> const& v)
{
return &(v.x);
@ -50,7 +50,7 @@ namespace glm
//! Return the address to the data of the vector input.
//! From GLM_GTC_type_ptr extension.
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T* value_ptr(vec<4, T, P>& v)
{
return &(v.x);
@ -58,7 +58,7 @@ namespace glm
/// Return the constant address to the data of the matrix input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T const* value_ptr(mat<2, 2, T, P> const& m)
{
return &(m[0].x);
@ -66,7 +66,7 @@ namespace glm
//! Return the address to the data of the matrix input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T* value_ptr(mat<2, 2, T, P>& m)
{
return &(m[0].x);
@ -74,7 +74,7 @@ namespace glm
/// Return the constant address to the data of the matrix input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T const* value_ptr(mat<3, 3, T, P> const& m)
{
return &(m[0].x);
@ -82,7 +82,7 @@ namespace glm
//! Return the address to the data of the matrix input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T* value_ptr(mat<3, 3, T, P>& m)
{
return &(m[0].x);
@ -90,7 +90,7 @@ namespace glm
/// Return the constant address to the data of the matrix input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T const* value_ptr(mat<4, 4, T, P> const& m)
{
return &(m[0].x);
@ -98,7 +98,7 @@ namespace glm
//! Return the address to the data of the matrix input.
//! From GLM_GTC_type_ptr extension.
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T* value_ptr(mat<4, 4, T, P>& m)
{
return &(m[0].x);
@ -106,7 +106,7 @@ namespace glm
/// Return the constant address to the data of the matrix input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T const* value_ptr(mat<2, 3, T, P> const& m)
{
return &(m[0].x);
@ -114,7 +114,7 @@ namespace glm
//! Return the address to the data of the matrix input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T* value_ptr(mat<2, 3, T, P>& m)
{
return &(m[0].x);
@ -122,7 +122,7 @@ namespace glm
/// Return the constant address to the data of the matrix input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T const* value_ptr(mat<3, 2, T, P> const& m)
{
return &(m[0].x);
@ -130,7 +130,7 @@ namespace glm
//! Return the address to the data of the matrix input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T* value_ptr(mat<3, 2, T, P>& m)
{
return &(m[0].x);
@ -138,7 +138,7 @@ namespace glm
/// Return the constant address to the data of the matrix input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T const* value_ptr(mat<2, 4, T, P> const& m)
{
return &(m[0].x);
@ -146,7 +146,7 @@ namespace glm
//! Return the address to the data of the matrix input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T* value_ptr(mat<2, 4, T, P>& m)
{
return &(m[0].x);
@ -154,7 +154,7 @@ namespace glm
/// Return the constant address to the data of the matrix input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T const* value_ptr(mat<4, 2, T, P> const& m)
{
return &(m[0].x);
@ -162,7 +162,7 @@ namespace glm
//! Return the address to the data of the matrix input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T* value_ptr(mat<4, 2, T, P>& m)
{
return &(m[0].x);
@ -170,7 +170,7 @@ namespace glm
/// Return the constant address to the data of the matrix input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T const* value_ptr(mat<3, 4, T, P> const& m)
{
return &(m[0].x);
@ -178,7 +178,7 @@ namespace glm
//! Return the address to the data of the matrix input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T* value_ptr(mat<3, 4, T, P>& m)
{
return &(m[0].x);
@ -186,7 +186,7 @@ namespace glm
/// Return the constant address to the data of the matrix input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T const* value_ptr(mat<4, 3, T, P> const& m)
{
return &(m[0].x);
@ -194,7 +194,7 @@ namespace glm
/// Return the address to the data of the matrix input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T * value_ptr(mat<4, 3, T, P>& m)
{
return &(m[0].x);
@ -202,7 +202,7 @@ namespace glm
/// Return the constant address to the data of the input parameter.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T const * value_ptr(tquat<T, P> const& q)
{
return &(q[0]);
@ -210,7 +210,7 @@ namespace glm
/// Return the address to the data of the quaternion input.
/// @see gtc_type_ptr
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T* value_ptr(tquat<T, P>& q)
{
return &(q[0]);

6
glm/gtc/ulp.hpp
View File

@ -15,7 +15,7 @@
// Dependencies
#include "../detail/setup.hpp"
#include "../detail/precision.hpp"
#include "../detail/qualifier.hpp"
#include "../detail/type_int.hpp"
#include "../detail/compute_vector_relational.hpp"
@ -55,8 +55,8 @@ namespace glm
/// Return the distance in the number of ULP between 2 vectors.
/// @see gtc_ulp
template<typename T, template<int, typename> class vecType>
GLM_FUNC_DECL vecType<2, uint> float_distance(vecType<2, T> const & x, vecType<2, T> const & y);
template<typename T, qualifier Q>
GLM_FUNC_DECL vec<2, uint, Q> float_distance(vec<2, T, Q> const & x, vec<2, T, Q> const & y);
/// @}
}// namespace glm

30
glm/gtc/ulp.inl
View File

@ -217,10 +217,10 @@ namespace glm
# endif
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> next_float(vecType<L, T, P> const & x)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> next_float(vec<L, T, P> const & x)
{
vecType<L, T, P> Result;
vec<L, T, P> Result;
for(length_t i = 0, n = Result.length(); i < n; ++i)
Result[i] = next_float(x[i]);
return Result;
@ -252,10 +252,10 @@ namespace glm
# endif
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> prev_float(vecType<L, T, P> const & x)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> prev_float(vec<L, T, P> const & x)
{
vecType<L, T, P> Result;
vec<L, T, P> Result;
for(length_t i = 0, n = Result.length(); i < n; ++i)
Result[i] = prev_float(x[i]);
return Result;
@ -270,10 +270,10 @@ namespace glm
return temp;
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> next_float(vecType<L, T, P> const & x, vecType<L, uint, P> const & ulps)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> next_float(vec<L, T, P> const & x, vec<L, uint, P> const & ulps)
{
vecType<L, T, P> Result;
vec<L, T, P> Result;
for(length_t i = 0, n = Result.length(); i < n; ++i)
Result[i] = next_float(x[i], ulps[i]);
return Result;
@ -288,10 +288,10 @@ namespace glm
return temp;
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> prev_float(vecType<L, T, P> const & x, vecType<L, uint, P> const & ulps)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> prev_float(vec<L, T, P> const & x, vec<L, uint, P> const & ulps)
{
vecType<L, T, P> Result;
vec<L, T, P> Result;
for(length_t i = 0, n = Result.length(); i < n; ++i)
Result[i] = prev_float(x[i], ulps[i]);
return Result;
@ -328,10 +328,10 @@ namespace glm
return ulp;
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, uint, P> float_distance(vecType<L, T, P> const & x, vecType<L, T, P> const & y)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, uint, P> float_distance(vec<L, T, P> const & x, vec<L, T, P> const & y)
{
vecType<L, uint, P> Result;
vec<L, uint, P> Result;
for(length_t i = 0, n = Result.length(); i < n; ++i)
Result[i] = float_distance(x[i], y[i]);
return Result;

60
glm/gtc/vec1.hpp
View File

@ -21,78 +21,78 @@
namespace glm
{
/// 1 component vector of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 1 component vector of high qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
/// @see gtc_vec1 extension.
typedef highp_vec1_t highp_vec1;
/// 1 component vector of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 1 component vector of medium qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
/// @see gtc_vec1 extension.
typedef mediump_vec1_t mediump_vec1;
/// 1 component vector of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 1 component vector of low qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
/// @see gtc_vec1 extension.
typedef lowp_vec1_t lowp_vec1;
/// 1 component vector of high precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 1 component vector of high qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
/// @see gtc_vec1 extension.
typedef highp_dvec1_t highp_dvec1;
/// 1 component vector of medium precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 1 component vector of medium qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
/// @see gtc_vec1 extension.
typedef mediump_dvec1_t mediump_dvec1;
/// 1 component vector of low precision floating-point numbers.
/// There is no guarantee on the actual precision.
/// 1 component vector of low qualifier floating-point numbers.
/// There is no guarantee on the actual qualifier.
/// @see gtc_vec1 extension.
typedef lowp_dvec1_t lowp_dvec1;
/// 1 component vector of high precision signed integer numbers.
/// There is no guarantee on the actual precision.
/// 1 component vector of high qualifier signed integer numbers.
/// There is no guarantee on the actual qualifier.
/// @see gtc_vec1 extension.
typedef highp_ivec1_t highp_ivec1;
/// 1 component vector of medium precision signed integer numbers.
/// There is no guarantee on the actual precision.
/// 1 component vector of medium qualifier signed integer numbers.
/// There is no guarantee on the actual qualifier.
/// @see gtc_vec1 extension.
typedef mediump_ivec1_t mediump_ivec1;
/// 1 component vector of low precision signed integer numbers.
/// There is no guarantee on the actual precision.
/// 1 component vector of low qualifier signed integer numbers.
/// There is no guarantee on the actual qualifier.
/// @see gtc_vec1 extension.
typedef lowp_ivec1_t lowp_ivec1;
/// 1 component vector of high precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
/// 1 component vector of high qualifier unsigned integer numbers.
/// There is no guarantee on the actual qualifier.
/// @see gtc_vec1 extension.
typedef highp_uvec1_t highp_uvec1;
/// 1 component vector of medium precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
/// 1 component vector of medium qualifier unsigned integer numbers.
/// There is no guarantee on the actual qualifier.
/// @see gtc_vec1 extension.
typedef mediump_uvec1_t mediump_uvec1;
/// 1 component vector of low precision unsigned integer numbers.
/// There is no guarantee on the actual precision.
/// 1 component vector of low qualifier unsigned integer numbers.
/// There is no guarantee on the actual qualifier.
/// @see gtc_vec1 extension.
typedef lowp_uvec1_t lowp_uvec1;
/// 1 component vector of high precision boolean.
/// There is no guarantee on the actual precision.
/// 1 component vector of high qualifier boolean.
/// There is no guarantee on the actual qualifier.
/// @see gtc_vec1 extension.
typedef highp_bvec1_t highp_bvec1;
/// 1 component vector of medium precision boolean.
/// There is no guarantee on the actual precision.
/// 1 component vector of medium qualifier boolean.
/// There is no guarantee on the actual qualifier.
/// @see gtc_vec1 extension.
typedef mediump_bvec1_t mediump_bvec1;
/// 1 component vector of low precision boolean.
/// There is no guarantee on the actual precision.
/// 1 component vector of low qualifier boolean.
/// There is no guarantee on the actual qualifier.
/// @see gtc_vec1 extension.
typedef lowp_bvec1_t lowp_bvec1;

158
glm/gtx/associated_min_max.hpp
View File

@ -30,29 +30,29 @@ namespace glm
/// Minimum comparison between 2 variables and returns 2 associated variable values
/// @see gtx_associated_min_max
template<typename T, typename U, precision P>
template<typename T, typename U, qualifier P>
GLM_FUNC_DECL U associatedMin(T x, U a, T y, U b);
/// Minimum comparison between 2 variables and returns 2 associated variable values
/// @see gtx_associated_min_max
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_DECL vec<2, U, P> associatedMin(
vecType<L, T, P> const& x, vecType<L, U, P> const & a,
vecType<L, T, P> const& y, vecType<L, U, P> const & b);
vec<L, T, P> const& x, vec<L, U, P> const & a,
vec<L, T, P> const& y, vec<L, U, P> const & b);
/// Minimum comparison between 2 variables and returns 2 associated variable values
/// @see gtx_associated_min_max
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, U, P> associatedMin(
T x, const vecType<L, U, P>& a,
T y, const vecType<L, U, P>& b);
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_DECL vec<L, U, P> associatedMin(
T x, const vec<L, U, P>& a,
T y, const vec<L, U, P>& b);
/// Minimum comparison between 2 variables and returns 2 associated variable values
/// @see gtx_associated_min_max
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, U, P> associatedMin(
vecType<L, T, P> const& x, U a,
vecType<L, T, P> const& y, U b);
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_DECL vec<L, U, P> associatedMin(
vec<L, T, P> const& x, U a,
vec<L, T, P> const& y, U b);
/// Minimum comparison between 3 variables and returns 3 associated variable values
/// @see gtx_associated_min_max
@ -64,11 +64,11 @@ namespace glm
/// Minimum comparison between 3 variables and returns 3 associated variable values
/// @see gtx_associated_min_max
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, U, P> associatedMin(
vecType<L, T, P> const& x, vecType<L, U, P> const & a,
vecType<L, T, P> const& y, vecType<L, U, P> const & b,
vecType<L, T, P> const& z, vecType<L, U, P> const & c);
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_DECL vec<L, U, P> associatedMin(
vec<L, T, P> const& x, vec<L, U, P> const & a,
vec<L, T, P> const& y, vec<L, U, P> const & b,
vec<L, T, P> const& z, vec<L, U, P> const & c);
/// Minimum comparison between 4 variables and returns 4 associated variable values
/// @see gtx_associated_min_max
@ -81,30 +81,30 @@ namespace glm
/// Minimum comparison between 4 variables and returns 4 associated variable values
/// @see gtx_associated_min_max
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, U, P> associatedMin(
vecType<L, T, P> const& x, vecType<L, U, P> const & a,
vecType<L, T, P> const& y, vecType<L, U, P> const & b,
vecType<L, T, P> const& z, vecType<L, U, P> const & c,
vecType<L, T, P> const& w, vecType<L, U, P> const & d);
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_DECL vec<L, U, P> associatedMin(
vec<L, T, P> const& x, vec<L, U, P> const & a,
vec<L, T, P> const& y, vec<L, U, P> const & b,
vec<L, T, P> const& z, vec<L, U, P> const & c,
vec<L, T, P> const& w, vec<L, U, P> const & d);
/// Minimum comparison between 4 variables and returns 4 associated variable values
/// @see gtx_associated_min_max
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, U, P> associatedMin(
T x, vecType<L, U, P> const & a,
T y, vecType<L, U, P> const & b,
T z, vecType<L, U, P> const & c,
T w, vecType<L, U, P> const & d);
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_DECL vec<L, U, P> associatedMin(
T x, vec<L, U, P> const & a,
T y, vec<L, U, P> const & b,
T z, vec<L, U, P> const & c,
T w, vec<L, U, P> const & d);
/// Minimum comparison between 4 variables and returns 4 associated variable values
/// @see gtx_associated_min_max
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, U, P> associatedMin(
vecType<L, T, P> const& x, U a,
vecType<L, T, P> const& y, U b,
vecType<L, T, P> const& z, U c,
vecType<L, T, P> const& w, U d);
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_DECL vec<L, U, P> associatedMin(
vec<L, T, P> const& x, U a,
vec<L, T, P> const& y, U b,
vec<L, T, P> const& z, U c,
vec<L, T, P> const& w, U d);
/// Maximum comparison between 2 variables and returns 2 associated variable values
/// @see gtx_associated_min_max
@ -113,24 +113,24 @@ namespace glm
/// Maximum comparison between 2 variables and returns 2 associated variable values
/// @see gtx_associated_min_max
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_DECL vec<2, U, P> associatedMax(
vecType<L, T, P> const& x, vecType<L, U, P> const & a,
vecType<L, T, P> const& y, vecType<L, U, P> const & b);
vec<L, T, P> const& x, vec<L, U, P> const & a,
vec<L, T, P> const& y, vec<L, U, P> const & b);
/// Maximum comparison between 2 variables and returns 2 associated variable values
/// @see gtx_associated_min_max
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, T, P> associatedMax(
T x, vecType<L, U, P> const & a,
T y, vecType<L, U, P> const & b);
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_DECL vec<L, T, P> associatedMax(
T x, vec<L, U, P> const & a,
T y, vec<L, U, P> const & b);
/// Maximum comparison between 2 variables and returns 2 associated variable values
/// @see gtx_associated_min_max
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, U, P> associatedMax(
vecType<L, T, P> const& x, U a,
vecType<L, T, P> const& y, U b);
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_DECL vec<L, U, P> associatedMax(
vec<L, T, P> const& x, U a,
vec<L, T, P> const& y, U b);
/// Maximum comparison between 3 variables and returns 3 associated variable values
/// @see gtx_associated_min_max
@ -142,27 +142,27 @@ namespace glm
/// Maximum comparison between 3 variables and returns 3 associated variable values
/// @see gtx_associated_min_max
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, U, P> associatedMax(
vecType<L, T, P> const& x, vecType<L, U, P> const & a,
vecType<L, T, P> const& y, vecType<L, U, P> const & b,
vecType<L, T, P> const& z, vecType<L, U, P> const & c);
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_DECL vec<L, U, P> associatedMax(
vec<L, T, P> const& x, vec<L, U, P> const & a,
vec<L, T, P> const& y, vec<L, U, P> const & b,
vec<L, T, P> const& z, vec<L, U, P> const & c);
/// Maximum comparison between 3 variables and returns 3 associated variable values
/// @see gtx_associated_min_max
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, T, P> associatedMax(
T x, vecType<L, U, P> const & a,
T y, vecType<L, U, P> const & b,
T z, vecType<L, U, P> const & c);
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_DECL vec<L, T, P> associatedMax(
T x, vec<L, U, P> const & a,
T y, vec<L, U, P> const & b,
T z, vec<L, U, P> const & c);
/// Maximum comparison between 3 variables and returns 3 associated variable values
/// @see gtx_associated_min_max
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, U, P> associatedMax(
vecType<L, T, P> const& x, U a,
vecType<L, T, P> const& y, U b,
vecType<L, T, P> const& z, U c);
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_DECL vec<L, U, P> associatedMax(
vec<L, T, P> const& x, U a,
vec<L, T, P> const& y, U b,
vec<L, T, P> const& z, U c);
/// Maximum comparison between 4 variables and returns 4 associated variable values
/// @see gtx_associated_min_max
@ -175,30 +175,30 @@ namespace glm
/// Maximum comparison between 4 variables and returns 4 associated variable values
/// @see gtx_associated_min_max
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, U, P> associatedMax(
vecType<L, T, P> const& x, vecType<L, U, P> const & a,
vecType<L, T, P> const& y, vecType<L, U, P> const & b,
vecType<L, T, P> const& z, vecType<L, U, P> const & c,
vecType<L, T, P> const& w, vecType<L, U, P> const & d);
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_DECL vec<L, U, P> associatedMax(
vec<L, T, P> const& x, vec<L, U, P> const & a,
vec<L, T, P> const& y, vec<L, U, P> const & b,
vec<L, T, P> const& z, vec<L, U, P> const & c,
vec<L, T, P> const& w, vec<L, U, P> const & d);
/// Maximum comparison between 4 variables and returns 4 associated variable values
/// @see gtx_associated_min_max
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, U, P> associatedMax(
T x, vecType<L, U, P> const & a,
T y, vecType<L, U, P> const & b,
T z, vecType<L, U, P> const & c,
T w, vecType<L, U, P> const & d);
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_DECL vec<L, U, P> associatedMax(
T x, vec<L, U, P> const & a,
T y, vec<L, U, P> const & b,
T z, vec<L, U, P> const & c,
T w, vec<L, U, P> const & d);
/// Maximum comparison between 4 variables and returns 4 associated variable values
/// @see gtx_associated_min_max
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, U, P> associatedMax(
vecType<L, T, P> const& x, U a,
vecType<L, T, P> const& y, U b,
vecType<L, T, P> const& z, U c,
vecType<L, T, P> const& w, U d);
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_DECL vec<L, U, P> associatedMax(
vec<L, T, P> const& x, U a,
vec<L, T, P> const& y, U b,
vec<L, T, P> const& z, U c,
vec<L, T, P> const& w, U d);
/// @}
} //namespace glm

190
glm/gtx/associated_min_max.inl
View File

@ -4,46 +4,46 @@
namespace glm{
// Min comparison between 2 variables
template<typename T, typename U, precision P>
template<typename T, typename U, qualifier P>
GLM_FUNC_QUALIFIER U associatedMin(T x, U a, T y, U b)
{
return x < y ? a : b;
}
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_QUALIFIER vec<2, U, P> associatedMin
(
vecType<L, T, P> const& x, vecType<L, U, P> const & a,
vecType<L, T, P> const& y, vecType<L, U, P> const & b
vec<L, T, P> const& x, vec<L, U, P> const & a,
vec<L, T, P> const& y, vec<L, U, P> const & b
)
{
vecType<L, U, P> Result;
vec<L, U, P> Result;
for(length_t i = 0, n = Result.length(); i < n; ++i)
Result[i] = x[i] < y[i] ? a[i] : b[i];
return Result;
}
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMin
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_QUALIFIER vec<L, U, P> associatedMin
(
T x, const vecType<L, U, P>& a,
T y, const vecType<L, U, P>& b
T x, const vec<L, U, P>& a,
T y, const vec<L, U, P>& b
)
{
vecType<L, U, P> Result;
vec<L, U, P> Result;
for(length_t i = 0, n = Result.length(); i < n; ++i)
Result[i] = x < y ? a[i] : b[i];
return Result;
}
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMin
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_QUALIFIER vec<L, U, P> associatedMin
(
vecType<L, T, P> const& x, U a,
vecType<L, T, P> const& y, U b
vec<L, T, P> const& x, U a,
vec<L, T, P> const& y, U b
)
{
vecType<L, U, P> Result;
vec<L, U, P> Result;
for(length_t i = 0, n = Result.length(); i < n; ++i)
Result[i] = x[i] < y[i] ? a : b;
return Result;
@ -62,15 +62,15 @@ GLM_FUNC_QUALIFIER U associatedMin
return Result;
}
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMin
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_QUALIFIER vec<L, U, P> associatedMin
(
vecType<L, T, P> const& x, vecType<L, U, P> const & a,
vecType<L, T, P> const& y, vecType<L, U, P> const & b,
vecType<L, T, P> const& z, vecType<L, U, P> const & c
vec<L, T, P> const& x, vec<L, U, P> const & a,
vec<L, T, P> const& y, vec<L, U, P> const & b,
vec<L, T, P> const& z, vec<L, U, P> const & c
)
{
vecType<L, U, P> Result;
vec<L, U, P> Result;
for(length_t i = 0, n = Result.length(); i < n; ++i)
Result[i] = x[i] < y[i] ? (x[i] < z[i] ? a[i] : c[i]) : (y[i] < z[i] ? b[i] : c[i]);
return Result;
@ -95,16 +95,16 @@ GLM_FUNC_QUALIFIER U associatedMin
}
// Min comparison between 4 variables
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMin
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_QUALIFIER vec<L, U, P> associatedMin
(
vecType<L, T, P> const& x, vecType<L, U, P> const & a,
vecType<L, T, P> const& y, vecType<L, U, P> const & b,
vecType<L, T, P> const& z, vecType<L, U, P> const & c,
vecType<L, T, P> const& w, vecType<L, U, P> const & d
vec<L, T, P> const& x, vec<L, U, P> const & a,
vec<L, T, P> const& y, vec<L, U, P> const & b,
vec<L, T, P> const& z, vec<L, U, P> const & c,
vec<L, T, P> const& w, vec<L, U, P> const & d
)
{
vecType<L, U, P> Result;
vec<L, U, P> Result;
for(length_t i = 0, n = Result.length(); i < n; ++i)
{
T Test1 = min(x[i], y[i]);
@ -117,19 +117,19 @@ GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMin
}
// Min comparison between 4 variables
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMin
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_QUALIFIER vec<L, U, P> associatedMin
(
T x, vecType<L, U, P> const & a,
T y, vecType<L, U, P> const & b,
T z, vecType<L, U, P> const & c,
T w, vecType<L, U, P> const & d
T x, vec<L, U, P> const & a,
T y, vec<L, U, P> const & b,
T z, vec<L, U, P> const & c,
T w, vec<L, U, P> const & d
)
{
T Test1 = min(x, y);
T Test2 = min(z, w);
vecType<L, U, P> Result;
vec<L, U, P> Result;
for(length_t i = 0, n = Result.length(); i < n; ++i)
{
U Result1 = x < y ? a[i] : b[i];
@ -140,16 +140,16 @@ GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMin
}
// Min comparison between 4 variables
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMin
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_QUALIFIER vec<L, U, P> associatedMin
(
vecType<L, T, P> const& x, U a,
vecType<L, T, P> const& y, U b,
vecType<L, T, P> const& z, U c,
vecType<L, T, P> const& w, U d
vec<L, T, P> const& x, U a,
vec<L, T, P> const& y, U b,
vec<L, T, P> const& z, U c,
vec<L, T, P> const& w, U d
)
{
vecType<L, U, P> Result;
vec<L, U, P> Result;
for(length_t i = 0, n = Result.length(); i < n; ++i)
{
T Test1 = min(x[i], y[i]);
@ -169,42 +169,42 @@ GLM_FUNC_QUALIFIER U associatedMax(T x, U a, T y, U b)
}
// Max comparison between 2 variables
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_QUALIFIER vec<2, U, P> associatedMax
(
vecType<L, T, P> const& x, vecType<L, U, P> const & a,
vecType<L, T, P> const& y, vecType<L, U, P> const & b
vec<L, T, P> const& x, vec<L, U, P> const & a,
vec<L, T, P> const& y, vec<L, U, P> const & b
)
{
vecType<L, U, P> Result;
vec<L, U, P> Result;
for(length_t i = 0, n = Result.length(); i < n; ++i)
Result[i] = x[i] > y[i] ? a[i] : b[i];
return Result;
}
// Max comparison between 2 variables
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> associatedMax
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> associatedMax
(
T x, vecType<L, U, P> const & a,
T y, vecType<L, U, P> const & b
T x, vec<L, U, P> const & a,
T y, vec<L, U, P> const & b
)
{
vecType<L, U, P> Result;
vec<L, U, P> Result;
for(length_t i = 0, n = Result.length(); i < n; ++i)
Result[i] = x > y ? a[i] : b[i];
return Result;
}
// Max comparison between 2 variables
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMax
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_QUALIFIER vec<L, U, P> associatedMax
(
vecType<L, T, P> const& x, U a,
vecType<L, T, P> const& y, U b
vec<L, T, P> const& x, U a,
vec<L, T, P> const& y, U b
)
{
vecType<L, T, P> Result;
vec<L, T, P> Result;
for(length_t i = 0, n = Result.length(); i < n; ++i)
Result[i] = x[i] > y[i] ? a : b;
return Result;
@ -224,45 +224,45 @@ GLM_FUNC_QUALIFIER U associatedMax
}
// Max comparison between 3 variables
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMax
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_QUALIFIER vec<L, U, P> associatedMax
(
vecType<L, T, P> const& x, vecType<L, U, P> const & a,
vecType<L, T, P> const& y, vecType<L, U, P> const & b,
vecType<L, T, P> const& z, vecType<L, U, P> const & c
vec<L, T, P> const& x, vec<L, U, P> const & a,
vec<L, T, P> const& y, vec<L, U, P> const & b,
vec<L, T, P> const& z, vec<L, U, P> const & c
)
{
vecType<L, U, P> Result;
vec<L, U, P> Result;
for(length_t i = 0, n = Result.length(); i < n; ++i)
Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a[i] : c[i]) : (y[i] > z[i] ? b[i] : c[i]);
return Result;
}
// Max comparison between 3 variables
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> associatedMax
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> associatedMax
(
T x, vecType<L, U, P> const & a,
T y, vecType<L, U, P> const & b,
T z, vecType<L, U, P> const & c
T x, vec<L, U, P> const & a,
T y, vec<L, U, P> const & b,
T z, vec<L, U, P> const & c
)
{
vecType<L, U, P> Result;
vec<L, U, P> Result;
for(length_t i = 0, n = Result.length(); i < n; ++i)
Result[i] = x > y ? (x > z ? a[i] : c[i]) : (y > z ? b[i] : c[i]);
return Result;
}
// Max comparison between 3 variables
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMax
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_QUALIFIER vec<L, U, P> associatedMax
(
vecType<L, T, P> const& x, U a,
vecType<L, T, P> const& y, U b,
vecType<L, T, P> const& z, U c
vec<L, T, P> const& x, U a,
vec<L, T, P> const& y, U b,
vec<L, T, P> const& z, U c
)
{
vecType<L, T, P> Result;
vec<L, T, P> Result;
for(length_t i = 0, n = Result.length(); i < n; ++i)
Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a : c) : (y[i] > z[i] ? b : c);
return Result;
@ -287,16 +287,16 @@ GLM_FUNC_QUALIFIER U associatedMax
}
// Max comparison between 4 variables
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMax
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_QUALIFIER vec<L, U, P> associatedMax
(
vecType<L, T, P> const& x, vecType<L, U, P> const & a,
vecType<L, T, P> const& y, vecType<L, U, P> const & b,
vecType<L, T, P> const& z, vecType<L, U, P> const & c,
vecType<L, T, P> const& w, vecType<L, U, P> const & d
vec<L, T, P> const& x, vec<L, U, P> const & a,
vec<L, T, P> const& y, vec<L, U, P> const & b,
vec<L, T, P> const& z, vec<L, U, P> const & c,
vec<L, T, P> const& w, vec<L, U, P> const & d
)
{
vecType<L, U, P> Result;
vec<L, U, P> Result;
for(length_t i = 0, n = Result.length(); i < n; ++i)
{
T Test1 = max(x[i], y[i]);
@ -309,19 +309,19 @@ GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMax
}
// Max comparison between 4 variables
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMax
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_QUALIFIER vec<L, U, P> associatedMax
(
T x, vecType<L, U, P> const & a,
T y, vecType<L, U, P> const & b,
T z, vecType<L, U, P> const & c,
T w, vecType<L, U, P> const & d
T x, vec<L, U, P> const & a,
T y, vec<L, U, P> const & b,
T z, vec<L, U, P> const & c,
T w, vec<L, U, P> const & d
)
{
T Test1 = max(x, y);
T Test2 = max(z, w);
vecType<L, U, P> Result;
vec<L, U, P> Result;
for(length_t i = 0, n = Result.length(); i < n; ++i)
{
U Result1 = x > y ? a[i] : b[i];
@ -332,16 +332,16 @@ GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMax
}
// Max comparison between 4 variables
template<length_t L, typename T, typename U, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, U, P> associatedMax
template<length_t L, typename T, typename U, qualifier P>
GLM_FUNC_QUALIFIER vec<L, U, P> associatedMax
(
vecType<L, T, P> const& x, U a,
vecType<L, T, P> const& y, U b,
vecType<L, T, P> const& z, U c,
vecType<L, T, P> const& w, U d
vec<L, T, P> const& x, U a,
vec<L, T, P> const& y, U b,
vec<L, T, P> const& z, U c,
vec<L, T, P> const& w, U d
)
{
vecType<L, U, P> Result;
vec<L, U, P> Result;
for(length_t i = 0, n = Result.length(); i < n; ++i)
{
T Test1 = max(x[i], y[i]);

16
glm/gtx/bit.hpp
View File

@ -39,8 +39,8 @@ namespace glm
/// Find the highest bit set to 1 in a integer variable and return its value.
///
/// @see gtx_bit
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_DECL vecType<L, T, P> highestBitValue(vecType<L, T, P> const & value);
template<length_t L, typename T, qualifier P>
GLM_FUNC_DECL vec<L, T, P> highestBitValue(vec<L, T, P> const& value);
/// Return the power of two number which value is just higher the input value.
/// Deprecated, use ceilPowerOfTwo from GTC_round instead
@ -55,8 +55,8 @@ namespace glm
///
/// @see gtc_round
/// @see gtx_bit
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_DEPRECATED GLM_FUNC_DECL vecType<L, T, P> powerOfTwoAbove(vecType<L, T, P> const & value);
template<length_t L, typename T, qualifier P>
GLM_DEPRECATED GLM_FUNC_DECL vec<L, T, P> powerOfTwoAbove(vec<L, T, P> const& value);
/// Return the power of two number which value is just lower the input value.
/// Deprecated, use floorPowerOfTwo from GTC_round instead
@ -71,8 +71,8 @@ namespace glm
///
/// @see gtc_round
/// @see gtx_bit
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_DEPRECATED GLM_FUNC_DECL vecType<L, T, P> powerOfTwoBelow(vecType<L, T, P> const & value);
template<length_t L, typename T, qualifier P>
GLM_DEPRECATED GLM_FUNC_DECL vec<L, T, P> powerOfTwoBelow(vec<L, T, P> const& value);
/// Return the power of two number which value is the closet to the input value.
/// Deprecated, use roundPowerOfTwo from GTC_round instead
@ -87,8 +87,8 @@ namespace glm
///
/// @see gtc_round
/// @see gtx_bit
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_DEPRECATED GLM_FUNC_DECL vecType<L, T, P> powerOfTwoNearest(vecType<L, T, P> const & value);
template<length_t L, typename T, qualifier P>
GLM_DEPRECATED GLM_FUNC_DECL vec<L, T, P> powerOfTwoNearest(vec<L, T, P> const& value);
/// @}
} //namespace glm

20
glm/gtx/bit.inl
View File

@ -19,8 +19,8 @@ namespace glm
return result;
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> highestBitValue(vecType<L, T, P> const & v)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> highestBitValue(vec<L, T, P> const & v)
{
return detail::functor1<L, T, T, P>::call(highestBitValue, v);
}
@ -34,8 +34,8 @@ namespace glm
return (Value & (~Value + 1));
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> lowestBitValue(vecType<L, T, P> const & v)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> lowestBitValue(vec<L, T, P> const& v)
{
return detail::functor1<L, T, T, P>::call(lowestBitValue, v);
}
@ -49,8 +49,8 @@ namespace glm
return isPowerOfTwo(value) ? value : highestBitValue(value) << 1;
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> powerOfTwoAbove(vecType<L, T, P> const & v)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> powerOfTwoAbove(vec<L, T, P> const& v)
{
return detail::functor1<L, T, T, P>::call(powerOfTwoAbove, v);
}
@ -64,8 +64,8 @@ namespace glm
return isPowerOfTwo(value) ? value : highestBitValue(value);
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> powerOfTwoBelow(vecType<L, T, P> const & v)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> powerOfTwoBelow(vec<L, T, P> const& v)
{
return detail::functor1<L, T, T, P>::call(powerOfTwoBelow, v);
}
@ -84,8 +84,8 @@ namespace glm
return (next - value) < (value - prev) ? next : prev;
}
template<length_t L, typename T, precision P, template<length_t, typename, precision> class vecType>
GLM_FUNC_QUALIFIER vecType<L, T, P> powerOfTwoNearest(vecType<L, T, P> const & v)
template<length_t L, typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<L, T, P> powerOfTwoNearest(vec<L, T, P> const& v)
{
return detail::functor1<L, T, T, P>::call(powerOfTwoNearest, v);
}

4
glm/gtx/closest_point.hpp
View File

@ -30,14 +30,14 @@ namespace glm
/// Find the point on a straight line which is the closet of a point.
/// @see gtx_closest_point
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> closestPointOnLine(
vec<3, T, P> const & point,
vec<3, T, P> const & a,
vec<3, T, P> const & b);
/// 2d lines work as well
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<2, T, P> closestPointOnLine(
vec<2, T, P> const & point,
vec<2, T, P> const & a,

4
glm/gtx/closest_point.inl
View File

@ -3,7 +3,7 @@
namespace glm
{
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> closestPointOnLine
(
vec<3, T, P> const & point,
@ -23,7 +23,7 @@ namespace glm
return a + LineDirection * Distance;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<2, T, P> closestPointOnLine
(
vec<2, T, P> const & point,

10
glm/gtx/color_encoding.hpp
View File

@ -15,7 +15,7 @@
// Dependencies
#include "../detail/setup.hpp"
#include "../detail/precision.hpp"
#include "../detail/qualifier.hpp"
#include "../vec3.hpp"
#include <limits>
@ -29,19 +29,19 @@ namespace glm
/// @{
/// Convert a linear sRGB color to D65 YUV.
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> convertLinearSRGBToD65XYZ(vec<3, T, P> const& ColorLinearSRGB);
/// Convert a linear sRGB color to D50 YUV.
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> convertLinearSRGBToD50XYZ(vec<3, T, P> const& ColorLinearSRGB);
/// Convert a D65 YUV color to linear sRGB.
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> convertD65XYZToLinearSRGB(vec<3, T, P> const& ColorD65XYZ);
/// Convert a D65 YUV color to D50 YUV.
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> convertD65XYZToD50XYZ(vec<3, T, P> const& ColorD65XYZ);
/// @}

8
glm/gtx/color_encoding.inl
View File

@ -3,7 +3,7 @@
namespace glm
{
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> convertLinearSRGBToD65XYZ(vec<3, T, P> const& ColorLinearSRGB)
{
vec<3, T, P> const M(0.490f, 0.17697f, 0.2f);
@ -13,7 +13,7 @@ namespace glm
return (M * ColorLinearSRGB + N * ColorLinearSRGB + O * ColorLinearSRGB) * static_cast<T>(5.650675255693055f);
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> convertLinearSRGBToD50XYZ(vec<3, T, P> const& ColorLinearSRGB)
{
vec<3, T, P> const M(0.436030342570117f, 0.222438466210245f, 0.013897440074263f);
@ -23,7 +23,7 @@ namespace glm
return M * ColorLinearSRGB + N * ColorLinearSRGB + O * ColorLinearSRGB;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> convertD65XYZToLinearSRGB(vec<3, T, P> const& ColorD65XYZ)
{
vec<3, T, P> const M(0.41847f, -0.091169f, 0.0009209f);
@ -33,7 +33,7 @@ namespace glm
return M * ColorD65XYZ + N * ColorD65XYZ + O * ColorD65XYZ;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> convertD65XYZToD50XYZ(vec<3, T, P> const& ColorD65XYZ)
{
vec<3, T, P> const M(+1.047844353856414f, +0.029549007606644f, -0.009250984365223f);

10
glm/gtx/color_space.hpp
View File

@ -30,13 +30,13 @@ namespace glm
/// Converts a color from HSV color space to its color in RGB color space.
/// @see gtx_color_space
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> rgbColor(
vec<3, T, P> const & hsvValue);
/// Converts a color from RGB color space to its color in HSV color space.
/// @see gtx_color_space
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> hsvColor(
vec<3, T, P> const & rgbValue);
@ -48,21 +48,21 @@ namespace glm
/// Modify the saturation of a color.
/// @see gtx_color_space
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<3, T, P> saturation(
T const s,
vec<3, T, P> const & color);
/// Modify the saturation of a color.
/// @see gtx_color_space
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL vec<4, T, P> saturation(
T const s,
vec<4, T, P> const & color);
/// Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals.
/// @see gtx_color_space
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_DECL T luminosity(
vec<3, T, P> const & color);

10
glm/gtx/color_space.inl
View File

@ -3,7 +3,7 @@
namespace glm
{
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> rgbColor(const vec<3, T, P>& hsvColor)
{
vec<3, T, P> hsv = hsvColor;
@ -60,7 +60,7 @@ namespace glm
return rgbColor;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> hsvColor(const vec<3, T, P>& rgbColor)
{
vec<3, T, P> hsv = rgbColor;
@ -121,19 +121,19 @@ namespace glm
return result;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<3, T, P> saturation(const T s, const vec<3, T, P>& color)
{
return vec<3, T, P>(saturation(s) * vec<4, T, P>(color, T(0)));
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER vec<4, T, P> saturation(const T s, const vec<4, T, P>& color)
{
return saturation(s) * color;
}
template<typename T, precision P>
template<typename T, qualifier P>
GLM_FUNC_QUALIFIER T luminosity(const vec<3, T, P>& color)
{
const vec<3, T, P> tmp = vec<3, T, P>(0.33, 0.59, 0.11);

Some files were not shown because too many files have changed in this diff Show More