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

Renamed tvec into vec

Browse Source
This commit is contained in:
Christophe Riccio 2016-12-30 00:03:34 +01:00
parent d7fd5a61da
commit 4dd748f380
31 changed files with 1365 additions and 1365 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
glm/detail/_swizzle.hpp
View File

@ -28,19 +28,19 @@ namespace detail
template <typename T, precision P, int E0, int E1, bool Aligned> template <typename T, precision P, int E0, int E1, bool Aligned>
struct _swizzle_base1<2, T, P, E0,E1,-1,-2, Aligned> : public _swizzle_base0<T, 2> struct _swizzle_base1<2, T, P, E0,E1,-1,-2, Aligned> : public _swizzle_base0<T, 2>
{ {
GLM_FUNC_QUALIFIER tvec<2, T, P> operator ()() const { return tvec<2, T, P>(this->elem(E0), this->elem(E1)); } 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, precision 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> struct _swizzle_base1<3, T, P, E0,E1,E2,-1, Aligned> : public _swizzle_base0<T, 3>
{ {
GLM_FUNC_QUALIFIER tvec<3, T, P> operator ()() const { return tvec<3, T, P>(this->elem(E0), this->elem(E1), this->elem(E2)); } 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, precision 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> struct _swizzle_base1<4, T, P, E0,E1,E2,E3, Aligned> : public _swizzle_base0<T, 4>
{ {
GLM_FUNC_QUALIFIER tvec<4, T, P> operator ()() const { return tvec<4, T, P>(this->elem(E0), this->elem(E1), this->elem(E2), this->elem(E3)); } 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)); }
}; };
// Internal class for implementing swizzle operators // Internal class for implementing swizzle operators
@ -65,7 +65,7 @@ namespace detail
return *this; return *this;
} }
GLM_FUNC_QUALIFIER _swizzle_base2& operator= (tvec<N, T, P> const& that) GLM_FUNC_QUALIFIER _swizzle_base2& operator= (vec<N, T, P> const& that)
{ {
struct op { struct op {
GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e = t; } GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e = t; }
@ -74,7 +74,7 @@ namespace detail
return *this; return *this;
} }
GLM_FUNC_QUALIFIER void operator -= (tvec<N, T, P> const& that) GLM_FUNC_QUALIFIER void operator -= (vec<N, T, P> const& that)
{ {
struct op { struct op {
GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e -= t; } GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e -= t; }
@ -82,7 +82,7 @@ namespace detail
_apply_op(that, op()); _apply_op(that, op());
} }
GLM_FUNC_QUALIFIER void operator += (tvec<N, T, P> const& that) GLM_FUNC_QUALIFIER void operator += (vec<N, T, P> const& that)
{ {
struct op { struct op {
GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e += t; } GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e += t; }
@ -90,7 +90,7 @@ namespace detail
_apply_op(that, op()); _apply_op(that, op());
} }
GLM_FUNC_QUALIFIER void operator *= (tvec<N, T, P> const& that) GLM_FUNC_QUALIFIER void operator *= (vec<N, T, P> const& that)
{ {
struct op { struct op {
GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e *= t; } GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e *= t; }
@ -98,7 +98,7 @@ namespace detail
_apply_op(that, op()); _apply_op(that, op());
} }
GLM_FUNC_QUALIFIER void operator /= (tvec<N, T, P> const& that) GLM_FUNC_QUALIFIER void operator /= (vec<N, T, P> const& that)
{ {
struct op { struct op {
GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e /= t; } GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e /= t; }
@ -119,7 +119,7 @@ namespace detail
protected: protected:
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER void _apply_op(tvec<N, T, P> const& that, U op) GLM_FUNC_QUALIFIER void _apply_op(vec<N, T, P> const& that, U op)
{ {
// Make a copy of the data in this == &that. // Make a copy of the data in this == &that.
// The copier should optimize out the copy in cases where the function is // The copier should optimize out the copy in cases where the function is
@ -154,7 +154,7 @@ namespace detail
using base_type::operator=; using base_type::operator=;
GLM_FUNC_QUALIFIER operator tvec<N, T, P> () const { return (*this)(); } GLM_FUNC_QUALIFIER operator vec<N, T, P> () const { return (*this)(); }
}; };
// //
@ -170,17 +170,17 @@ namespace detail
// //
#define _GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \ #define _GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \
_GLM_SWIZZLE_TEMPLATE2 \ _GLM_SWIZZLE_TEMPLATE2 \
GLM_FUNC_QUALIFIER tvec<N, T, P> operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b) \ GLM_FUNC_QUALIFIER vec<N, T, P> operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b) \
{ \ { \
return a() OPERAND b(); \ return a() OPERAND b(); \
} \ } \
_GLM_SWIZZLE_TEMPLATE1 \ _GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER tvec<N, T, P> operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const tvec<N, T, P>& b) \ GLM_FUNC_QUALIFIER vec<N, T, P> operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const vec<N, T, P>& b) \
{ \ { \
return a() OPERAND b; \ return a() OPERAND b; \
} \ } \
_GLM_SWIZZLE_TEMPLATE1 \ _GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER tvec<N, T, P> operator OPERAND ( const tvec<N, T, P>& a, const _GLM_SWIZZLE_TYPE1& b) \ GLM_FUNC_QUALIFIER vec<N, T, P> operator OPERAND ( const vec<N, T, P>& a, const _GLM_SWIZZLE_TYPE1& b) \
{ \ { \
return a OPERAND b(); \ return a OPERAND b(); \
} }
@ -190,12 +190,12 @@ namespace detail
// //
#define _GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \ #define _GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \
_GLM_SWIZZLE_TEMPLATE1 \ _GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER tvec<N, T, P> operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const T& b) \ GLM_FUNC_QUALIFIER vec<N, T, P> operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const T& b) \
{ \ { \
return a() OPERAND b; \ return a() OPERAND b; \
} \ } \
_GLM_SWIZZLE_TEMPLATE1 \ _GLM_SWIZZLE_TEMPLATE1 \
GLM_FUNC_QUALIFIER tvec<N, T, P> operator OPERAND ( const T& a, const _GLM_SWIZZLE_TYPE1& b) \ GLM_FUNC_QUALIFIER vec<N, T, P> operator OPERAND ( const T& a, const _GLM_SWIZZLE_TYPE1& b) \
{ \ { \
return a OPERAND b(); \ return a OPERAND b(); \
} }

2
glm/detail/func_common.inl
View File

@ -326,7 +326,7 @@ namespace detail
std::numeric_limits<genFIType>::is_iec559 || (std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer), std::numeric_limits<genFIType>::is_iec559 || (std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer),
"'sign' only accept signed inputs"); "'sign' only accept signed inputs");
return detail::compute_sign<1, genFIType, defaultp, tvec, std::numeric_limits<genFIType>::is_iec559, highp>::call(tvec1<genFIType>(x)).x; return detail::compute_sign<1, genFIType, defaultp, vec, std::numeric_limits<genFIType>::is_iec559, highp>::call(tvec1<genFIType>(x)).x;
} }
template <int D, typename T, precision P, template <int, typename, precision> class vecType> template <int D, typename T, precision P, template <int, typename, precision> class vecType>

36
glm/detail/func_common_simd.inl
View File

@ -11,7 +11,7 @@ namespace glm{
namespace detail namespace detail
{ {
template <precision P> template <precision P>
struct compute_abs_vector<4, float, P, tvec, true> struct compute_abs_vector<4, float, P, vec, true>
{ {
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v) GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
{ {
@ -22,7 +22,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_abs_vector<4, int, P, tvec, true> struct compute_abs_vector<4, int, P, vec, true>
{ {
GLM_FUNC_QUALIFIER static tvec4<int, P> call(tvec4<int, P> const & v) GLM_FUNC_QUALIFIER static tvec4<int, P> call(tvec4<int, P> const & v)
{ {
@ -33,7 +33,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_floor<4, float, P, tvec, true> struct compute_floor<4, float, P, vec, true>
{ {
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v) GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
{ {
@ -44,7 +44,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_ceil<4, float, P, tvec, true> struct compute_ceil<4, float, P, vec, true>
{ {
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v) GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
{ {
@ -55,7 +55,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_fract<4, float, P, tvec, true> struct compute_fract<4, float, P, vec, true>
{ {
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v) GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
{ {
@ -66,7 +66,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_round<4, float, P, tvec, true> struct compute_round<4, float, P, vec, true>
{ {
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v) GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
{ {
@ -77,7 +77,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_mod<4, float, P, tvec, true> struct compute_mod<4, float, P, vec, true>
{ {
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & x, tvec4<float, P> const & y) GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & x, tvec4<float, P> const & y)
{ {
@ -88,7 +88,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_min_vector<4, float, P, tvec, true> struct compute_min_vector<4, float, P, vec, true>
{ {
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v1, tvec4<float, P> const & v2) GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v1, tvec4<float, P> const & v2)
{ {
@ -99,7 +99,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_min_vector<4, int32, P, tvec, true> struct compute_min_vector<4, int32, P, vec, true>
{ {
GLM_FUNC_QUALIFIER static tvec4<int32, P> call(tvec4<int32, P> const & v1, tvec4<int32, P> const & v2) GLM_FUNC_QUALIFIER static tvec4<int32, P> call(tvec4<int32, P> const & v1, tvec4<int32, P> const & v2)
{ {
@ -110,7 +110,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_min_vector<4, uint32, P, tvec, true> struct compute_min_vector<4, uint32, P, vec, true>
{ {
GLM_FUNC_QUALIFIER static tvec4<int32, P> call(tvec4<uint32, P> const & v1, tvec4<uint32, P> const & v2) GLM_FUNC_QUALIFIER static tvec4<int32, P> call(tvec4<uint32, P> const & v1, tvec4<uint32, P> const & v2)
{ {
@ -121,7 +121,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_max_vector<4, float, P, tvec, true> struct compute_max_vector<4, float, P, vec, true>
{ {
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v1, tvec4<float, P> const & v2) GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v1, tvec4<float, P> const & v2)
{ {
@ -132,7 +132,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_max_vector<4, int32, P, tvec, true> struct compute_max_vector<4, int32, P, vec, true>
{ {
GLM_FUNC_QUALIFIER static tvec4<int32, P> call(tvec4<int32, P> const & v1, tvec4<int32, P> const & v2) GLM_FUNC_QUALIFIER static tvec4<int32, P> call(tvec4<int32, P> const & v1, tvec4<int32, P> const & v2)
{ {
@ -143,7 +143,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_max_vector<4, uint32, P, tvec, true> struct compute_max_vector<4, uint32, P, vec, true>
{ {
GLM_FUNC_QUALIFIER static tvec4<uint32, P> call(tvec4<uint32, P> const & v1, tvec4<uint32, P> const & v2) GLM_FUNC_QUALIFIER static tvec4<uint32, P> call(tvec4<uint32, P> const & v1, tvec4<uint32, P> const & v2)
{ {
@ -154,7 +154,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_clamp_vector<4, float, P, tvec, true> struct compute_clamp_vector<4, float, P, vec, true>
{ {
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & x, tvec4<float, P> const & minVal, tvec4<float, P> const & maxVal) GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & x, tvec4<float, P> const & minVal, tvec4<float, P> const & maxVal)
{ {
@ -165,7 +165,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_clamp_vector<4, int32, P, tvec, true> struct compute_clamp_vector<4, int32, P, vec, true>
{ {
GLM_FUNC_QUALIFIER static tvec4<int32, P> call(tvec4<int32, P> const & x, tvec4<int32, P> const & minVal, tvec4<int32, P> const & maxVal) GLM_FUNC_QUALIFIER static tvec4<int32, P> call(tvec4<int32, P> const & x, tvec4<int32, P> const & minVal, tvec4<int32, P> const & maxVal)
{ {
@ -176,7 +176,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_clamp_vector<4, uint32, P, tvec, true> struct compute_clamp_vector<4, uint32, P, vec, true>
{ {
GLM_FUNC_QUALIFIER static tvec4<uint32, P> call(tvec4<uint32, P> const & x, tvec4<uint32, P> const & minVal, tvec4<uint32, P> const & maxVal) GLM_FUNC_QUALIFIER static tvec4<uint32, P> call(tvec4<uint32, P> const & x, tvec4<uint32, P> const & minVal, tvec4<uint32, P> const & maxVal)
{ {
@ -187,7 +187,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_mix_vector<4, float, bool, P, tvec, true> struct compute_mix_vector<4, float, bool, P, vec, true>
{ {
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & x, tvec4<float, P> const & y, tvec4<bool, P> const & a) GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & x, tvec4<float, P> const & y, tvec4<bool, P> const & a)
{ {
@ -216,7 +216,7 @@ namespace detail
}; };
*/ */
template <precision P> template <precision P>
struct compute_smoothstep_vector<4, float, P, tvec, true> struct compute_smoothstep_vector<4, float, P, vec, true>
{ {
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& edge0, tvec4<float, P> const& edge1, tvec4<float, P> const& x) GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& edge0, tvec4<float, P> const& edge1, tvec4<float, P> const& x)
{ {

18
glm/detail/func_exponential.inl
View File

@ -23,7 +23,7 @@ namespace detail
template <int D, typename T, precision P, template <int, class, precision> class vecType, bool isFloat, bool Aligned> template <int D, typename T, precision P, template <int, class, precision> class vecType, bool isFloat, bool Aligned>
struct compute_log2 struct compute_log2
{ {
GLM_FUNC_QUALIFIER static tvec<D, T, P> call(tvec<D, T, P> const & vec) GLM_FUNC_QUALIFIER static vec<D, T, P> call(vec<D, T, P> const & vec)
{ {
return detail::functor1<D, T, T, P>::call(log2, vec); return detail::functor1<D, T, T, P>::call(log2, vec);
} }
@ -32,7 +32,7 @@ namespace detail
template <int D, typename T, precision P, bool Aligned> template <int D, typename T, precision P, bool Aligned>
struct compute_sqrt struct compute_sqrt
{ {
GLM_FUNC_QUALIFIER static tvec<D, T, P> call(tvec<D, T, P> const & x) GLM_FUNC_QUALIFIER static vec<D, T, P> call(vec<D, T, P> const & x)
{ {
return detail::functor1<D, T, T, P>::call(std::sqrt, x); return detail::functor1<D, T, T, P>::call(std::sqrt, x);
} }
@ -41,7 +41,7 @@ namespace detail
template <int D, typename T, precision P, bool Aligned> template <int D, typename T, precision P, bool Aligned>
struct compute_inversesqrt struct compute_inversesqrt
{ {
GLM_FUNC_QUALIFIER static tvec<D, T, P> call(tvec<D, T, P> const & x) GLM_FUNC_QUALIFIER static vec<D, T, P> call(vec<D, T, P> const & x)
{ {
return static_cast<T>(1) / sqrt(x); return static_cast<T>(1) / sqrt(x);
} }
@ -50,13 +50,13 @@ namespace detail
template <int D, bool Aligned> template <int D, bool Aligned>
struct compute_inversesqrt<D, float, lowp, Aligned> struct compute_inversesqrt<D, float, lowp, Aligned>
{ {
GLM_FUNC_QUALIFIER static tvec<D, float, lowp> call(tvec<D, float, lowp> const & x) GLM_FUNC_QUALIFIER static vec<D, float, lowp> call(vec<D, float, lowp> const & x)
{ {
tvec<D, float, lowp> tmp(x); vec<D, float, lowp> tmp(x);
tvec<D, float, lowp> xhalf(tmp * 0.5f); vec<D, float, lowp> xhalf(tmp * 0.5f);
tvec<D, uint, lowp>* p = reinterpret_cast<tvec<D, uint, lowp>*>(const_cast<tvec<D, float, lowp>*>(&x)); vec<D, uint, lowp>* p = reinterpret_cast<vec<D, uint, lowp>*>(const_cast<vec<D, float, lowp>*>(&x));
tvec<D, uint, lowp> i = tvec<D, uint, lowp>(0x5f375a86) - (*p >> tvec<D, uint, lowp>(1)); vec<D, uint, lowp> i = vec<D, uint, lowp>(0x5f375a86) - (*p >> vec<D, uint, lowp>(1));
tvec<D, float, lowp>* ptmp = reinterpret_cast<tvec<D, float, lowp>*>(&i); vec<D, float, lowp>* ptmp = reinterpret_cast<vec<D, float, lowp>*>(&i);
tmp = *ptmp; tmp = *ptmp;
tmp = tmp * (1.5f - xhalf * tmp * tmp); tmp = tmp * (1.5f - xhalf * tmp * tmp);
return tmp; return tmp;

4
glm/detail/func_geometric.hpp
View File

@ -46,8 +46,8 @@ namespace glm
/// @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> /// @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 <int D, typename T, precision P> template <int D, typename T, precision P>
GLM_FUNC_DECL T dot( GLM_FUNC_DECL T dot(
tvec<D, T, P> const & x, vec<D, T, P> const & x,
tvec<D, T, P> const & y); vec<D, T, P> const & y);
/// Returns the cross product of x and y. /// Returns the cross product of x and y.
/// ///

24
glm/detail/func_geometric.inl
View File

@ -32,28 +32,28 @@ namespace detail
struct compute_dot{}; struct compute_dot{};
template <typename T, precision P, bool Aligned> template <typename T, precision P, bool Aligned>
struct compute_dot<tvec<1, T, P>, T, Aligned> struct compute_dot<vec<1, T, P>, T, Aligned>
{ {
GLM_FUNC_QUALIFIER static T call(tvec<1, T, P> const & a, tvec<1, T, P> const & b) GLM_FUNC_QUALIFIER static T call(vec<1, T, P> const & a, vec<1, T, P> const & b)
{ {
return a.x * b.x; return a.x * b.x;
} }
}; };
template <typename T, precision P, bool Aligned> template <typename T, precision P, bool Aligned>
struct compute_dot<tvec<2, T, P>, T, Aligned> struct compute_dot<vec<2, T, P>, T, Aligned>
{ {
GLM_FUNC_QUALIFIER static T call(tvec<2, T, P> const & a, tvec<2, T, P> const & b) GLM_FUNC_QUALIFIER static T call(vec<2, T, P> const & a, vec<2, T, P> const & b)
{ {
tvec<2, T, P> tmp(a * b); vec<2, T, P> tmp(a * b);
return tmp.x + tmp.y; return tmp.x + tmp.y;
} }
}; };
template <typename T, precision P, bool Aligned> template <typename T, precision P, bool Aligned>
struct compute_dot<tvec<3, T, P>, T, Aligned> struct compute_dot<vec<3, T, P>, T, Aligned>
{ {
GLM_FUNC_QUALIFIER static T call(tvec<3, T, P> const & a, tvec<3, T, P> const & b) GLM_FUNC_QUALIFIER static T call(vec<3, T, P> const & a, vec<3, T, P> const & b)
{ {
tvec3<T, P> tmp(a * b); tvec3<T, P> tmp(a * b);
return tmp.x + tmp.y + tmp.z; return tmp.x + tmp.y + tmp.z;
@ -61,11 +61,11 @@ namespace detail
}; };
template <typename T, precision P, bool Aligned> template <typename T, precision P, bool Aligned>
struct compute_dot<tvec<4, T, P>, T, Aligned> struct compute_dot<vec<4, T, P>, T, Aligned>
{ {
GLM_FUNC_QUALIFIER static T call(tvec<4, T, P> const & a, tvec<4, T, P> const & b) GLM_FUNC_QUALIFIER static T call(vec<4, T, P> const & a, vec<4, T, P> const & b)
{ {
tvec<4, T, P> tmp(a * b); vec<4, T, P> tmp(a * b);
return (tmp.x + tmp.y) + (tmp.z + tmp.w); return (tmp.x + tmp.y) + (tmp.z + tmp.w);
} }
}; };
@ -168,10 +168,10 @@ namespace detail
} }
template <int D, typename T, precision P> template <int D, typename T, precision P>
GLM_FUNC_QUALIFIER T dot(tvec<D, T, P> const & x, tvec<D, T, P> const & y) GLM_FUNC_QUALIFIER T dot(vec<D, T, P> const & x, vec<D, T, P> const & y)
{ {
GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' accepts only floating-point inputs"); GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' accepts only floating-point inputs");
return detail::compute_dot<tvec<D, T, P>, T, detail::is_aligned<P>::value>::call(x, y); return detail::compute_dot<vec<D, T, P>, T, detail::is_aligned<P>::value>::call(x, y);
} }
template <typename T, precision P> template <typename T, precision P>

18
glm/detail/func_geometric_simd.inl
View File

@ -9,16 +9,16 @@ namespace glm{
namespace detail namespace detail
{ {
template <precision P> template <precision P>
struct compute_length<tvec, 4, float, P, true> struct compute_length<vec, 4, float, P, true>
{ {
GLM_FUNC_QUALIFIER static float call(tvec<4, float, P> const & v) GLM_FUNC_QUALIFIER static float call(vec<4, float, P> const & v)
{ {
return _mm_cvtss_f32(glm_vec4_length(v.data)); return _mm_cvtss_f32(glm_vec4_length(v.data));
} }
}; };
template <precision P> template <precision P>
struct compute_distance<tvec, 4, float, P, true> struct compute_distance<vec, 4, float, P, true>
{ {
GLM_FUNC_QUALIFIER static float call(tvec4<float, P> const & p0, tvec4<float, P> const & p1) GLM_FUNC_QUALIFIER static float call(tvec4<float, P> const & p0, tvec4<float, P> const & p1)
{ {
@ -27,9 +27,9 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_dot<tvec<4, float, P>, float, true> struct compute_dot<vec<4, float, P>, float, true>
{ {
GLM_FUNC_QUALIFIER static float call(tvec<4, float, P> const& x, tvec<4, float, P> const& y) GLM_FUNC_QUALIFIER static float call(vec<4, float, P> const& x, vec<4, float, P> const& y)
{ {
return _mm_cvtss_f32(glm_vec1_dot(x.data, y.data)); return _mm_cvtss_f32(glm_vec1_dot(x.data, y.data));
} }
@ -51,7 +51,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_normalize<4, float, P, tvec, true> struct compute_normalize<4, float, P, vec, true>
{ {
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v) GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
{ {
@ -62,7 +62,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_faceforward<4, float, P, tvec, true> struct compute_faceforward<4, float, P, vec, true>
{ {
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& N, tvec4<float, P> const& I, tvec4<float, P> const& Nref) GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& N, tvec4<float, P> const& I, tvec4<float, P> const& Nref)
{ {
@ -73,7 +73,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_reflect<4, float, P, tvec, true> struct compute_reflect<4, float, P, vec, true>
{ {
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& I, tvec4<float, P> const& N) GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& I, tvec4<float, P> const& N)
{ {
@ -84,7 +84,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_refract<4, float, P, tvec, true> struct compute_refract<4, float, P, vec, true>
{ {
GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& I, tvec4<float, P> const& N, float eta) GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& I, tvec4<float, P> const& N, float eta)
{ {

4
glm/detail/func_integer_simd.inl
View File

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

18
glm/detail/func_matrix.hpp
View File

@ -35,55 +35,55 @@ namespace glm{
namespace detail namespace detail
{ {
template <typename T, precision P> template <typename T, precision P>
struct outerProduct_trait<2, 2, T, P, tvec, tvec> struct outerProduct_trait<2, 2, T, P, vec, vec>
{ {
typedef tmat2x2<T, P> type; typedef tmat2x2<T, P> type;
}; };
template <typename T, precision P> template <typename T, precision P>
struct outerProduct_trait<2, 3, T, P, tvec, tvec> struct outerProduct_trait<2, 3, T, P, vec, vec>
{ {
typedef tmat3x2<T, P> type; typedef tmat3x2<T, P> type;
}; };
template <typename T, precision P> template <typename T, precision P>
struct outerProduct_trait<2, 4, T, P, tvec, tvec> struct outerProduct_trait<2, 4, T, P, vec, vec>
{ {
typedef tmat4x2<T, P> type; typedef tmat4x2<T, P> type;
}; };
template <typename T, precision P> template <typename T, precision P>
struct outerProduct_trait<3, 2, T, P, tvec, tvec> struct outerProduct_trait<3, 2, T, P, vec, vec>
{ {
typedef tmat2x3<T, P> type; typedef tmat2x3<T, P> type;
}; };
template <typename T, precision P> template <typename T, precision P>
struct outerProduct_trait<3, 3, T, P, tvec, tvec> struct outerProduct_trait<3, 3, T, P, vec, vec>
{ {
typedef tmat3x3<T, P> type; typedef tmat3x3<T, P> type;
}; };
template <typename T, precision P> template <typename T, precision P>
struct outerProduct_trait<3, 4, T, P, tvec, tvec> struct outerProduct_trait<3, 4, T, P, vec, vec>
{ {
typedef tmat4x3<T, P> type; typedef tmat4x3<T, P> type;
}; };
template <typename T, precision P> template <typename T, precision P>
struct outerProduct_trait<4, 2, T, P, tvec, tvec> struct outerProduct_trait<4, 2, T, P, vec, vec>
{ {
typedef tmat2x4<T, P> type; typedef tmat2x4<T, P> type;
}; };
template <typename T, precision P> template <typename T, precision P>
struct outerProduct_trait<4, 3, T, P, tvec, tvec> struct outerProduct_trait<4, 3, T, P, vec, vec>
{ {
typedef tmat3x4<T, P> type; typedef tmat3x4<T, P> type;
}; };
template <typename T, precision P> template <typename T, precision P>
struct outerProduct_trait<4, 4, T, P, tvec, tvec> struct outerProduct_trait<4, 4, T, P, vec, vec>
{ {
typedef tmat4x4<T, P> type; typedef tmat4x4<T, P> type;
}; };

6
glm/detail/func_matrix_simd.inl
View File

@ -61,7 +61,7 @@ namespace detail
}//namespace detail }//namespace detail
template<> template<>
GLM_FUNC_QUALIFIER tmat4x4<float, aligned_lowp> outerProduct<4, 4, float, aligned_lowp, tvec, tvec>(tvec4<float, aligned_lowp> const & c, tvec4<float, aligned_lowp> const & r) GLM_FUNC_QUALIFIER tmat4x4<float, aligned_lowp> outerProduct<4, 4, float, aligned_lowp, vec, vec>(tvec4<float, aligned_lowp> const & c, tvec4<float, aligned_lowp> const & r)
{ {
tmat4x4<float, aligned_lowp> m(uninitialize); tmat4x4<float, aligned_lowp> m(uninitialize);
glm_mat4_outerProduct(c.data, r.data, *reinterpret_cast<__m128(*)[4]>(&m[0].data)); glm_mat4_outerProduct(c.data, r.data, *reinterpret_cast<__m128(*)[4]>(&m[0].data));
@ -69,7 +69,7 @@ namespace detail
} }
template<> template<>
GLM_FUNC_QUALIFIER tmat4x4<float, aligned_mediump> outerProduct<4, 4, float, aligned_mediump, tvec, tvec>(tvec4<float, aligned_mediump> const & c, tvec4<float, aligned_mediump> const & r) GLM_FUNC_QUALIFIER tmat4x4<float, aligned_mediump> outerProduct<4, 4, float, aligned_mediump, vec, vec>(tvec4<float, aligned_mediump> const & c, tvec4<float, aligned_mediump> const & r)
{ {
tmat4x4<float, aligned_mediump> m(uninitialize); tmat4x4<float, aligned_mediump> m(uninitialize);
glm_mat4_outerProduct(c.data, r.data, *reinterpret_cast<__m128(*)[4]>(&m[0].data)); glm_mat4_outerProduct(c.data, r.data, *reinterpret_cast<__m128(*)[4]>(&m[0].data));
@ -77,7 +77,7 @@ namespace detail
} }
template<> template<>
GLM_FUNC_QUALIFIER tmat4x4<float, aligned_highp> outerProduct<4, 4, float, aligned_highp, tvec, tvec>(tvec4<float, aligned_highp> const & c, tvec4<float, aligned_highp> const & r) GLM_FUNC_QUALIFIER tmat4x4<float, aligned_highp> outerProduct<4, 4, float, aligned_highp, vec, vec>(tvec4<float, aligned_highp> const & c, tvec4<float, aligned_highp> const & r)
{ {
tmat4x4<float, aligned_highp> m(uninitialize); tmat4x4<float, aligned_highp> m(uninitialize);
glm_mat4_outerProduct(c.data, r.data, *reinterpret_cast<__m128(*)[4]>(&m[0].data)); glm_mat4_outerProduct(c.data, r.data, *reinterpret_cast<__m128(*)[4]>(&m[0].data));

240
glm/detail/glm.cpp
View File

@ -9,140 +9,140 @@
namespace glm namespace glm
{ {
// tvec1 type explicit instantiation // tvec1 type explicit instantiation
template struct tvec<1, uint8, lowp>; template struct vec<1, uint8, lowp>;
template struct tvec<1, uint16, lowp>; template struct vec<1, uint16, lowp>;
template struct tvec<1, uint32, lowp>; template struct vec<1, uint32, lowp>;
template struct tvec<1, uint64, lowp>; template struct vec<1, uint64, lowp>;
template struct tvec<1, int8, lowp>; template struct vec<1, int8, lowp>;
template struct tvec<1, int16, lowp>; template struct vec<1, int16, lowp>;
template struct tvec<1, int32, lowp>; template struct vec<1, int32, lowp>;
template struct tvec<1, int64, lowp>; template struct vec<1, int64, lowp>;
template struct tvec<1, float32, lowp>; template struct vec<1, float32, lowp>;
template struct tvec<1, float64, lowp>; template struct vec<1, float64, lowp>;
template struct tvec<1, uint8, mediump>; template struct vec<1, uint8, mediump>;
template struct tvec<1, uint16, mediump>; template struct vec<1, uint16, mediump>;
template struct tvec<1, uint32, mediump>; template struct vec<1, uint32, mediump>;
template struct tvec<1, uint64, mediump>; template struct vec<1, uint64, mediump>;
template struct tvec<1, int8, mediump>; template struct vec<1, int8, mediump>;
template struct tvec<1, int16, mediump>; template struct vec<1, int16, mediump>;
template struct tvec<1, int32, mediump>; template struct vec<1, int32, mediump>;
template struct tvec<1, int64, mediump>; template struct vec<1, int64, mediump>;
template struct tvec<1, float32, mediump>; template struct vec<1, float32, mediump>;
template struct tvec<1, float64, mediump>; template struct vec<1, float64, mediump>;
template struct tvec<1, uint8, highp>; template struct vec<1, uint8, highp>;
template struct tvec<1, uint16, highp>; template struct vec<1, uint16, highp>;
template struct tvec<1, uint32, highp>; template struct vec<1, uint32, highp>;
template struct tvec<1, uint64, highp>; template struct vec<1, uint64, highp>;
template struct tvec<1, int8, highp>; template struct vec<1, int8, highp>;
template struct tvec<1, int16, highp>; template struct vec<1, int16, highp>;
template struct tvec<1, int32, highp>; template struct vec<1, int32, highp>;
template struct tvec<1, int64, highp>; template struct vec<1, int64, highp>;
template struct tvec<1, float32, highp>; template struct vec<1, float32, highp>;
template struct tvec<1, float64, highp>; template struct vec<1, float64, highp>;
// tvec2 type explicit instantiation // tvec2 type explicit instantiation
template struct tvec<2, uint8, lowp>; template struct vec<2, uint8, lowp>;
template struct tvec<2, uint16, lowp>; template struct vec<2, uint16, lowp>;
template struct tvec<2, uint32, lowp>; template struct vec<2, uint32, lowp>;
template struct tvec<2, uint64, lowp>; template struct vec<2, uint64, lowp>;
template struct tvec<2, int8, lowp>; template struct vec<2, int8, lowp>;
template struct tvec<2, int16, lowp>; template struct vec<2, int16, lowp>;
template struct tvec<2, int32, lowp>; template struct vec<2, int32, lowp>;
template struct tvec<2, int64, lowp>; template struct vec<2, int64, lowp>;
template struct tvec<2, float32, lowp>; template struct vec<2, float32, lowp>;
template struct tvec<2, float64, lowp>; template struct vec<2, float64, lowp>;
template struct tvec<2, uint8, mediump>; template struct vec<2, uint8, mediump>;
template struct tvec<2, uint16, mediump>; template struct vec<2, uint16, mediump>;
template struct tvec<2, uint32, mediump>; template struct vec<2, uint32, mediump>;
template struct tvec<2, uint64, mediump>; template struct vec<2, uint64, mediump>;
template struct tvec<2, int8, mediump>; template struct vec<2, int8, mediump>;
template struct tvec<2, int16, mediump>; template struct vec<2, int16, mediump>;
template struct tvec<2, int32, mediump>; template struct vec<2, int32, mediump>;
template struct tvec<2, int64, mediump>; template struct vec<2, int64, mediump>;
template struct tvec<2, float32, mediump>; template struct vec<2, float32, mediump>;
template struct tvec<2, float64, mediump>; template struct vec<2, float64, mediump>;
template struct tvec<2, uint8, highp>; template struct vec<2, uint8, highp>;
template struct tvec<2, uint16, highp>; template struct vec<2, uint16, highp>;
template struct tvec<2, uint32, highp>; template struct vec<2, uint32, highp>;
template struct tvec<2, uint64, highp>; template struct vec<2, uint64, highp>;
template struct tvec<2, int8, highp>; template struct vec<2, int8, highp>;
template struct tvec<2, int16, highp>; template struct vec<2, int16, highp>;
template struct tvec<2, int32, highp>; template struct vec<2, int32, highp>;
template struct tvec<2, int64, highp>; template struct vec<2, int64, highp>;
template struct tvec<2, float32, highp>; template struct vec<2, float32, highp>;
template struct tvec<2, float64, highp>; template struct vec<2, float64, highp>;
// tvec3 type explicit instantiation // tvec3 type explicit instantiation
template struct tvec<3, uint8, lowp>; template struct vec<3, uint8, lowp>;
template struct tvec<3, uint16, lowp>; template struct vec<3, uint16, lowp>;
template struct tvec<3, uint32, lowp>; template struct vec<3, uint32, lowp>;
template struct tvec<3, uint64, lowp>; template struct vec<3, uint64, lowp>;
template struct tvec<3, int8, lowp>; template struct vec<3, int8, lowp>;
template struct tvec<3, int16, lowp>; template struct vec<3, int16, lowp>;
template struct tvec<3, int32, lowp>; template struct vec<3, int32, lowp>;
template struct tvec<3, int64, lowp>; template struct vec<3, int64, lowp>;
template struct tvec<3, float32, lowp>; template struct vec<3, float32, lowp>;
template struct tvec<3, float64, lowp>; template struct vec<3, float64, lowp>;
template struct tvec<3, uint8, mediump>; template struct vec<3, uint8, mediump>;
template struct tvec<3, uint16, mediump>; template struct vec<3, uint16, mediump>;
template struct tvec<3, uint32, mediump>; template struct vec<3, uint32, mediump>;
template struct tvec<3, uint64, mediump>; template struct vec<3, uint64, mediump>;
template struct tvec<3, int8, mediump>; template struct vec<3, int8, mediump>;
template struct tvec<3, int16, mediump>; template struct vec<3, int16, mediump>;
template struct tvec<3, int32, mediump>; template struct vec<3, int32, mediump>;
template struct tvec<3, int64, mediump>; template struct vec<3, int64, mediump>;
template struct tvec<3, float32, mediump>; template struct vec<3, float32, mediump>;
template struct tvec<3, float64, mediump>; template struct vec<3, float64, mediump>;
template struct tvec<3, uint8, highp>; template struct vec<3, uint8, highp>;
template struct tvec<3, uint16, highp>; template struct vec<3, uint16, highp>;
template struct tvec<3, uint32, highp>; template struct vec<3, uint32, highp>;
template struct tvec<3, uint64, highp>; template struct vec<3, uint64, highp>;
template struct tvec<3, int8, highp>; template struct vec<3, int8, highp>;
template struct tvec<3, int16, highp>; template struct vec<3, int16, highp>;
template struct tvec<3, int32, highp>; template struct vec<3, int32, highp>;
template struct tvec<3, int64, highp>; template struct vec<3, int64, highp>;
template struct tvec<3, float32, highp>; template struct vec<3, float32, highp>;
template struct tvec<3, float64, highp>; template struct vec<3, float64, highp>;
// tvec4 type explicit instantiation // tvec4 type explicit instantiation
template struct tvec<4, uint8, lowp>; template struct vec<4, uint8, lowp>;
template struct tvec<4, uint16, lowp>; template struct vec<4, uint16, lowp>;
template struct tvec<4, uint32, lowp>; template struct vec<4, uint32, lowp>;
template struct tvec<4, uint64, lowp>; template struct vec<4, uint64, lowp>;
template struct tvec<4, int8, lowp>; template struct vec<4, int8, lowp>;
template struct tvec<4, int16, lowp>; template struct vec<4, int16, lowp>;
template struct tvec<4, int32, lowp>; template struct vec<4, int32, lowp>;
template struct tvec<4, int64, lowp>; template struct vec<4, int64, lowp>;
template struct tvec<4, float32, lowp>; template struct vec<4, float32, lowp>;
template struct tvec<4, float64, lowp>; template struct vec<4, float64, lowp>;
template struct tvec<4, uint8, mediump>; template struct vec<4, uint8, mediump>;
template struct tvec<4, uint16, mediump>; template struct vec<4, uint16, mediump>;
template struct tvec<4, uint32, mediump>; template struct vec<4, uint32, mediump>;
template struct tvec<4, uint64, mediump>; template struct vec<4, uint64, mediump>;
template struct tvec<4, int8, mediump>; template struct vec<4, int8, mediump>;
template struct tvec<4, int16, mediump>; template struct vec<4, int16, mediump>;
template struct tvec<4, int32, mediump>; template struct vec<4, int32, mediump>;
template struct tvec<4, int64, mediump>; template struct vec<4, int64, mediump>;
template struct tvec<4, float32, mediump>; template struct vec<4, float32, mediump>;
template struct tvec<4, float64, mediump>; template struct vec<4, float64, mediump>;
template struct tvec<4, uint8, highp>; template struct vec<4, uint8, highp>;
template struct tvec<4, uint16, highp>; template struct vec<4, uint16, highp>;
template struct tvec<4, uint32, highp>; template struct vec<4, uint32, highp>;
template struct tvec<4, uint64, highp>; template struct vec<4, uint64, highp>;
template struct tvec<4, int8, highp>; template struct vec<4, int8, highp>;
template struct tvec<4, int16, highp>; template struct vec<4, int16, highp>;
template struct tvec<4, int32, highp>; template struct vec<4, int32, highp>;
template struct tvec<4, int64, highp>; template struct vec<4, int64, highp>;
template struct tvec<4, float32, highp>; template struct vec<4, float32, highp>;
template struct tvec<4, float64, highp>; template struct vec<4, float64, highp>;
// tmat2x2 type explicit instantiation // tmat2x2 type explicit instantiation
template struct tmat2x2<float32, lowp>; template struct tmat2x2<float32, lowp>;

2
glm/detail/type_mat.hpp
View File

@ -12,7 +12,7 @@ namespace detail
struct outerProduct_trait{}; struct outerProduct_trait{};
}//namespace detail }//namespace detail
template <int D, typename T, precision P> struct tvec; template <int D, typename T, precision P> struct vec;
template <typename T, precision P> struct tmat2x2; template <typename T, precision P> struct tmat2x2;
template <typename T, precision P> struct tmat2x3; template <typename T, precision P> struct tmat2x3;
template <typename T, precision P> struct tmat2x4; template <typename T, precision P> struct tmat2x4;

10
glm/detail/type_vec.hpp
View File

@ -101,12 +101,12 @@ namespace detail
# endif # endif
}//namespace detail }//namespace detail
template <int D, typename T, precision P = defaultp> struct tvec; template <int D, typename T, precision P = defaultp> struct vec;
template <typename T, precision P = defaultp> using tvec1 = tvec<1, T, P>; template <typename T, precision P = defaultp> using tvec1 = vec<1, T, P>;
template <typename T, precision P = defaultp> using tvec2 = tvec<2, T, P>; template <typename T, precision P = defaultp> using tvec2 = vec<2, T, P>;
template <typename T, precision P = defaultp> using tvec3 = tvec<3, T, P>; template <typename T, precision P = defaultp> using tvec3 = vec<3, T, P>;
template <typename T, precision P = defaultp> using tvec4 = tvec<4, T, P>; template <typename T, precision P = defaultp> using tvec4 = vec<4, T, P>;
typedef tvec1<float, highp> highp_vec1_t; typedef tvec1<float, highp> highp_vec1_t;
typedef tvec1<float, mediump> mediump_vec1_t; typedef tvec1<float, mediump> mediump_vec1_t;

150
glm/detail/type_vec1.hpp
View File

@ -17,13 +17,13 @@
namespace glm namespace glm
{ {
template <typename T, precision P> template <typename T, precision P>
struct tvec<1, T, P> struct vec<1, T, P>
{ {
// -- Implementation detail -- // -- Implementation detail --
typedef T value_type; typedef T value_type;
typedef tvec type; typedef vec type;
typedef tvec<1, bool, P> bool_type; typedef vec<1, bool, P> bool_type;
// -- Data -- // -- Data --
@ -82,31 +82,31 @@ namespace glm
// -- Implicit basic constructors -- // -- Implicit basic constructors --
GLM_FUNC_DECL GLM_CONSTEXPR tvec() GLM_DEFAULT_CTOR; GLM_FUNC_DECL GLM_CONSTEXPR vec() GLM_DEFAULT_CTOR;
GLM_FUNC_DECL GLM_CONSTEXPR tvec(tvec const & v) GLM_DEFAULT; GLM_FUNC_DECL GLM_CONSTEXPR vec(vec const & v) GLM_DEFAULT;
template <precision Q> template <precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR tvec(tvec<1, T, Q> const & v); GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, T, Q> const & v);
// -- Explicit basic constructors -- // -- Explicit basic constructors --
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit tvec(ctor); GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit vec(ctor);
GLM_FUNC_DECL GLM_CONSTEXPR explicit tvec(T scalar); GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar);
// -- Conversion vector constructors -- // -- Conversion vector constructors --
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec(tvec<2, U, Q> const & v); GLM_FUNC_DECL GLM_CONSTEXPR 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) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec(tvec<3, U, Q> const & v); GLM_FUNC_DECL GLM_CONSTEXPR 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) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec(tvec<4, U, Q> const & v); GLM_FUNC_DECL GLM_CONSTEXPR 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) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec(tvec<1, U, Q> const & v); GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<1, U, Q> const & v);
// -- Swizzle constructors -- // -- Swizzle constructors --
/* /*
@ -120,178 +120,178 @@ namespace glm
*/ */
// -- Unary arithmetic operators -- // -- Unary arithmetic operators --
GLM_FUNC_DECL tvec & operator=(tvec const & v) GLM_DEFAULT; GLM_FUNC_DECL vec & operator=(vec const & v) GLM_DEFAULT;
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator+=(U scalar); GLM_FUNC_DECL vec & operator+=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator+=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator+=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator-=(U scalar); GLM_FUNC_DECL vec & operator-=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator-=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator-=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator*=(U scalar); GLM_FUNC_DECL vec & operator*=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator*=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator*=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator/=(U scalar); GLM_FUNC_DECL vec & operator/=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator/=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator/=(vec<1, U, P> const & v);
// -- Increment and decrement operators -- // -- Increment and decrement operators --
GLM_FUNC_DECL tvec & operator++(); GLM_FUNC_DECL vec & operator++();
GLM_FUNC_DECL tvec & operator--(); GLM_FUNC_DECL vec & operator--();
GLM_FUNC_DECL tvec operator++(int); GLM_FUNC_DECL vec operator++(int);
GLM_FUNC_DECL tvec operator--(int); GLM_FUNC_DECL vec operator--(int);
// -- Unary bit operators -- // -- Unary bit operators --
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator%=(U scalar); GLM_FUNC_DECL vec & operator%=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator%=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator%=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator&=(U scalar); GLM_FUNC_DECL vec & operator&=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator&=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator&=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator|=(U scalar); GLM_FUNC_DECL vec & operator|=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator|=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator|=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator^=(U scalar); GLM_FUNC_DECL vec & operator^=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator^=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator^=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator<<=(U scalar); GLM_FUNC_DECL vec & operator<<=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator<<=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator<<=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator>>=(U scalar); GLM_FUNC_DECL vec & operator>>=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator>>=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator>>=(vec<1, U, P> const & v);
}; };
// -- Unary operators -- // -- Unary operators --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator+(tvec<1, T, P> const & v); GLM_FUNC_DECL vec<1, T, P> operator+(vec<1, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator-(tvec<1, T, P> const & v); GLM_FUNC_DECL vec<1, T, P> operator-(vec<1, T, P> const & v);
// -- Binary operators -- // -- Binary operators --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator+(tvec<1, T, P> const & v, T scalar); GLM_FUNC_DECL vec<1, T, P> operator+(vec<1, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator+(T scalar, tvec<1, T, P> const & v); GLM_FUNC_DECL vec<1, T, P> operator+(T scalar, vec<1, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator+(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator-(tvec<1, T, P> const & v, T scalar); GLM_FUNC_DECL vec<1, T, P> operator-(vec<1, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator-(T scalar, tvec<1, T, P> const & v); GLM_FUNC_DECL vec<1, T, P> operator-(T scalar, vec<1, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator- (tvec<1, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator*(tvec<1, T, P> const & v, T scalar); GLM_FUNC_DECL vec<1, T, P> operator*(vec<1, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator*(T scalar, tvec<1, T, P> const & v); GLM_FUNC_DECL vec<1, T, P> operator*(T scalar, vec<1, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator*(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator/(tvec<1, T, P> const & v, T scalar); GLM_FUNC_DECL vec<1, T, P> operator/(vec<1, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator/(T scalar, tvec<1, T, P> const & v); GLM_FUNC_DECL vec<1, T, P> operator/(T scalar, vec<1, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator/(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator%(tvec<1, T, P> const & v, T scalar); GLM_FUNC_DECL vec<1, T, P> operator%(vec<1, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator%(T scalar, tvec<1, T, P> const & v); GLM_FUNC_DECL vec<1, T, P> operator%(T scalar, vec<1, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator%(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator&(tvec<1, T, P> const & v, T scalar); GLM_FUNC_DECL vec<1, T, P> operator&(vec<1, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator&(T scalar, tvec<1, T, P> const & v); GLM_FUNC_DECL vec<1, T, P> operator&(T scalar, vec<1, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator&(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator|(tvec<1, T, P> const & v, T scalar); GLM_FUNC_DECL vec<1, T, P> operator|(vec<1, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator|(T scalar, tvec<1, T, P> const & v); GLM_FUNC_DECL vec<1, T, P> operator|(T scalar, vec<1, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator|(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator^(tvec<1, T, P> const & v, T scalar); GLM_FUNC_DECL vec<1, T, P> operator^(vec<1, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator^(T scalar, tvec<1, T, P> const & v); GLM_FUNC_DECL vec<1, T, P> operator^(T scalar, vec<1, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator^(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator<<(tvec<1, T, P> const & v, T scalar); GLM_FUNC_DECL vec<1, T, P> operator<<(vec<1, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator<<(T scalar, tvec<1, T, P> const & v); GLM_FUNC_DECL vec<1, T, P> operator<<(T scalar, vec<1, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator<<(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator>>(tvec<1, T, P> const & v, T scalar); GLM_FUNC_DECL vec<1, T, P> operator>>(vec<1, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator>>(T scalar, tvec<1, T, P> const & v); GLM_FUNC_DECL vec<1, T, P> operator>>(T scalar, vec<1, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator>>(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<1, T, P> operator~(tvec<1, T, P> const & v); GLM_FUNC_DECL vec<1, T, P> operator~(vec<1, T, P> const & v);
// -- Boolean operators -- // -- Boolean operators --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL bool operator==(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL bool operator!=(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2); GLM_FUNC_DECL bool operator!=(vec<1, T, P> const & v1, vec<1, T, P> const & v2);
template <precision P> template <precision P>
GLM_FUNC_DECL tvec<1, bool, P> operator&&(tvec<1, bool, P> const & v1, tvec<1, bool, P> const & v2); GLM_FUNC_DECL vec<1, bool, P> operator&&(vec<1, bool, P> const & v1, vec<1, bool, P> const & v2);
template <precision P> template <precision P>
GLM_FUNC_DECL tvec<1, bool, P> operator||(tvec<1, bool, P> const & v1, tvec<1, bool, P> const & v2); GLM_FUNC_DECL vec<1, bool, P> operator||(vec<1, bool, P> const & v1, vec<1, bool, P> const & v2);
}//namespace glm }//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE #ifndef GLM_EXTERNAL_TEMPLATE

220
glm/detail/type_vec1.inl
View File

@ -7,7 +7,7 @@ namespace glm
# if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT) # if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec<1, T, P>::tvec() GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, P>::vec()
# ifndef GLM_FORCE_NO_CTOR_INIT # ifndef GLM_FORCE_NO_CTOR_INIT
: x(0) : x(0)
# endif # endif
@ -16,25 +16,25 @@ namespace glm
# if !GLM_HAS_DEFAULTED_FUNCTIONS # if !GLM_HAS_DEFAULTED_FUNCTIONS
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec<1, T, P>::tvec(tvec<1, T, P> const & v) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, P>::vec(vec<1, T, P> const & v)
: x(v.x) : x(v.x)
{} {}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS # endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template <typename T, precision P> template <typename T, precision P>
template <precision Q> template <precision Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec<1, T, P>::tvec(tvec<1, T, Q> const & v) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, P>::vec(vec<1, T, Q> const & v)
: x(v.x) : x(v.x)
{} {}
// -- Explicit basic constructors -- // -- Explicit basic constructors --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR tvec<1, T, P>::tvec(ctor) GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<1, T, P>::vec(ctor)
{} {}
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec<1, T, P>::tvec(T scalar) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, P>::vec(T scalar)
: x(scalar) : x(scalar)
{} {}
@ -42,39 +42,39 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U, precision Q> template <typename U, precision Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec<1, T, P>::tvec(tvec<1, U, Q> const & v) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, P>::vec(vec<1, U, Q> const & v)
: x(static_cast<T>(v.x)) : x(static_cast<T>(v.x))
{} {}
template <typename T, precision P> template <typename T, precision P>
template <typename U, precision Q> template <typename U, precision Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec<1, T, P>::tvec(tvec<2, U, Q> const & v) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, P>::vec(vec<2, U, Q> const & v)
: x(static_cast<T>(v.x)) : x(static_cast<T>(v.x))
{} {}
template <typename T, precision P> template <typename T, precision P>
template <typename U, precision Q> template <typename U, precision Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec<1, T, P>::tvec(tvec<3, U, Q> const & v) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, P>::vec(vec<3, U, Q> const & v)
: x(static_cast<T>(v.x)) : x(static_cast<T>(v.x))
{} {}
template <typename T, precision P> template <typename T, precision P>
template <typename U, precision Q> template <typename U, precision Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec<1, T, P>::tvec(tvec<4, U, Q> const & v) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<1, T, P>::vec(vec<4, U, Q> const & v)
: x(static_cast<T>(v.x)) : x(static_cast<T>(v.x))
{} {}
// -- Component accesses -- // -- Component accesses --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER T & tvec<1, T, P>::operator[](typename tvec<1, T, P>::length_type i) GLM_FUNC_QUALIFIER T & vec<1, T, P>::operator[](typename vec<1, T, P>::length_type i)
{ {
assert(i >= 0 && i < this->length()); assert(i >= 0 && i < this->length());
return (&x)[i]; return (&x)[i];
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER T const & tvec<1, T, P>::operator[](typename tvec<1, T, P>::length_type i) const 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()); assert(i >= 0 && i < this->length());
return (&x)[i]; return (&x)[i];
@ -84,7 +84,7 @@ namespace glm
# if !GLM_HAS_DEFAULTED_FUNCTIONS # if !GLM_HAS_DEFAULTED_FUNCTIONS
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator=(tvec<1, T, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator=(vec<1, T, P> const & v)
{ {
this->x = v.x; this->x = v.x;
return *this; return *this;
@ -93,7 +93,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator=(tvec<1, U, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator=(vec<1, U, P> const & v)
{ {
this->x = static_cast<T>(v.x); this->x = static_cast<T>(v.x);
return *this; return *this;
@ -101,7 +101,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator+=(U scalar) GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator+=(U scalar)
{ {
this->x += static_cast<T>(scalar); this->x += static_cast<T>(scalar);
return *this; return *this;
@ -109,7 +109,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator+=(tvec<1, U, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator+=(vec<1, U, P> const & v)
{ {
this->x += static_cast<T>(v.x); this->x += static_cast<T>(v.x);
return *this; return *this;
@ -117,7 +117,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator-=(U scalar) GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator-=(U scalar)
{ {
this->x -= static_cast<T>(scalar); this->x -= static_cast<T>(scalar);
return *this; return *this;
@ -125,7 +125,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator-=(tvec<1, U, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator-=(vec<1, U, P> const & v)
{ {
this->x -= static_cast<T>(v.x); this->x -= static_cast<T>(v.x);
return *this; return *this;
@ -133,7 +133,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator*=(U scalar) GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator*=(U scalar)
{ {
this->x *= static_cast<T>(scalar); this->x *= static_cast<T>(scalar);
return *this; return *this;
@ -141,7 +141,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator*=(tvec<1, U, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator*=(vec<1, U, P> const & v)
{ {
this->x *= static_cast<T>(v.x); this->x *= static_cast<T>(v.x);
return *this; return *this;
@ -149,7 +149,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator/=(U scalar) GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator/=(U scalar)
{ {
this->x /= static_cast<T>(scalar); this->x /= static_cast<T>(scalar);
return *this; return *this;
@ -157,7 +157,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator/=(tvec<1, U, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator/=(vec<1, U, P> const & v)
{ {
this->x /= static_cast<T>(v.x); this->x /= static_cast<T>(v.x);
return *this; return *this;
@ -166,31 +166,31 @@ namespace glm
// -- Increment and decrement operators -- // -- Increment and decrement operators --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator++() GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator++()
{ {
++this->x; ++this->x;
return *this; return *this;
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator--() GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator--()
{ {
--this->x; --this->x;
return *this; return *this;
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> tvec<1, T, P>::operator++(int) GLM_FUNC_QUALIFIER vec<1, T, P> vec<1, T, P>::operator++(int)
{ {
tvec<1, T, P> Result(*this); vec<1, T, P> Result(*this);
++*this; ++*this;
return Result; return Result;
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> tvec<1, T, P>::operator--(int) GLM_FUNC_QUALIFIER vec<1, T, P> vec<1, T, P>::operator--(int)
{ {
tvec<1, T, P> Result(*this); vec<1, T, P> Result(*this);
--*this; --*this;
return Result; return Result;
} }
@ -199,7 +199,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator%=(U scalar) GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator%=(U scalar)
{ {
this->x %= static_cast<T>(scalar); this->x %= static_cast<T>(scalar);
return *this; return *this;
@ -207,7 +207,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator%=(tvec<1, U, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator%=(vec<1, U, P> const & v)
{ {
this->x %= static_cast<T>(v.x); this->x %= static_cast<T>(v.x);
return *this; return *this;
@ -215,7 +215,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator&=(U scalar) GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator&=(U scalar)
{ {
this->x &= static_cast<T>(scalar); this->x &= static_cast<T>(scalar);
return *this; return *this;
@ -223,7 +223,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator&=(tvec<1, U, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator&=(vec<1, U, P> const & v)
{ {
this->x &= static_cast<T>(v.x); this->x &= static_cast<T>(v.x);
return *this; return *this;
@ -231,7 +231,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator|=(U scalar) GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator|=(U scalar)
{ {
this->x |= static_cast<T>(scalar); this->x |= static_cast<T>(scalar);
return *this; return *this;
@ -239,7 +239,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator|=(tvec<1, U, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator|=(vec<1, U, P> const & v)
{ {
this->x |= U(v.x); this->x |= U(v.x);
return *this; return *this;
@ -247,7 +247,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator^=(U scalar) GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator^=(U scalar)
{ {
this->x ^= static_cast<T>(scalar); this->x ^= static_cast<T>(scalar);
return *this; return *this;
@ -255,7 +255,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator^=(tvec<1, U, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator^=(vec<1, U, P> const & v)
{ {
this->x ^= static_cast<T>(v.x); this->x ^= static_cast<T>(v.x);
return *this; return *this;
@ -263,7 +263,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator<<=(U scalar) GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator<<=(U scalar)
{ {
this->x <<= static_cast<T>(scalar); this->x <<= static_cast<T>(scalar);
return *this; return *this;
@ -271,7 +271,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator<<=(tvec<1, U, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator<<=(vec<1, U, P> const & v)
{ {
this->x <<= static_cast<T>(v.x); this->x <<= static_cast<T>(v.x);
return *this; return *this;
@ -279,7 +279,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator>>=(U scalar) GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator>>=(U scalar)
{ {
this->x >>= static_cast<T>(scalar); this->x >>= static_cast<T>(scalar);
return *this; return *this;
@ -287,7 +287,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<1, T, P> & tvec<1, T, P>::operator>>=(tvec<1, U, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> & vec<1, T, P>::operator>>=(vec<1, U, P> const & v)
{ {
this->x >>= static_cast<T>(v.x); this->x >>= static_cast<T>(v.x);
return *this; return *this;
@ -296,263 +296,263 @@ namespace glm
// -- Unary constant operators -- // -- Unary constant operators --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator+(tvec<1, T, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> operator+(vec<1, T, P> const & v)
{ {
return v; return v;
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator-(tvec<1, T, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> operator-(vec<1, T, P> const & v)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
-v.x); -v.x);
} }
// -- Binary arithmetic operators -- // -- Binary arithmetic operators --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator+(tvec<1, T, P> const & v, T scalar) GLM_FUNC_QUALIFIER vec<1, T, P> operator+(vec<1, T, P> const & v, T scalar)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
v.x + scalar); v.x + scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator+(T scalar, tvec<1, T, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> operator+(T scalar, vec<1, T, P> const & v)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
scalar + v.x); scalar + v.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator+(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2) GLM_FUNC_QUALIFIER vec<1, T, P> operator+(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
v1.x + v2.x); v1.x + v2.x);
} }
//operator- //operator-
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator-(tvec<1, T, P> const & v, T scalar) GLM_FUNC_QUALIFIER vec<1, T, P> operator-(vec<1, T, P> const & v, T scalar)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
v.x - scalar); v.x - scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator-(T scalar, tvec<1, T, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> operator-(T scalar, vec<1, T, P> const & v)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
scalar - v.x); scalar - v.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator-(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2) GLM_FUNC_QUALIFIER vec<1, T, P> operator-(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
v1.x - v2.x); v1.x - v2.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator*(tvec<1, T, P> const & v, T scalar) GLM_FUNC_QUALIFIER vec<1, T, P> operator*(vec<1, T, P> const & v, T scalar)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
v.x * scalar); v.x * scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator*(T scalar, tvec<1, T, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> operator*(T scalar, vec<1, T, P> const & v)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
scalar * v.x); scalar * v.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator*(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2) GLM_FUNC_QUALIFIER vec<1, T, P> operator*(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
v1.x * v2.x); v1.x * v2.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator/(tvec<1, T, P> const & v, T scalar) GLM_FUNC_QUALIFIER vec<1, T, P> operator/(vec<1, T, P> const & v, T scalar)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
v.x / scalar); v.x / scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator/(T scalar, tvec<1, T, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> operator/(T scalar, vec<1, T, P> const & v)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
scalar / v.x); scalar / v.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator/(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2) GLM_FUNC_QUALIFIER vec<1, T, P> operator/(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
v1.x / v2.x); v1.x / v2.x);
} }
// -- Binary bit operators -- // -- Binary bit operators --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator%(tvec<1, T, P> const & v, T scalar) GLM_FUNC_QUALIFIER vec<1, T, P> operator%(vec<1, T, P> const & v, T scalar)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
v.x % scalar); v.x % scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator%(T scalar, tvec<1, T, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> operator%(T scalar, vec<1, T, P> const & v)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
scalar % v.x); scalar % v.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator%(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2) GLM_FUNC_QUALIFIER vec<1, T, P> operator%(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
v1.x % v2.x); v1.x % v2.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator&(tvec<1, T, P> const & v, T scalar) GLM_FUNC_QUALIFIER vec<1, T, P> operator&(vec<1, T, P> const & v, T scalar)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
v.x & scalar); v.x & scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator&(T scalar, tvec<1, T, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> operator&(T scalar, vec<1, T, P> const & v)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
scalar & v.x); scalar & v.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator&(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2) GLM_FUNC_QUALIFIER vec<1, T, P> operator&(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
v1.x & v2.x); v1.x & v2.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator|(tvec<1, T, P> const & v, T scalar) GLM_FUNC_QUALIFIER vec<1, T, P> operator|(vec<1, T, P> const & v, T scalar)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
v.x | scalar); v.x | scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator|(T scalar, tvec<1, T, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> operator|(T scalar, vec<1, T, P> const & v)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
scalar | v.x); scalar | v.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator|(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2) GLM_FUNC_QUALIFIER vec<1, T, P> operator|(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
v1.x | v2.x); v1.x | v2.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator^(tvec<1, T, P> const & v, T scalar) GLM_FUNC_QUALIFIER vec<1, T, P> operator^(vec<1, T, P> const & v, T scalar)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
v.x ^ scalar); v.x ^ scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator^(T scalar, tvec<1, T, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> operator^(T scalar, vec<1, T, P> const & v)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
scalar ^ v.x); scalar ^ v.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator^(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2) GLM_FUNC_QUALIFIER vec<1, T, P> operator^(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
v1.x ^ v2.x); v1.x ^ v2.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator<<(tvec<1, T, P> const & v, T scalar) GLM_FUNC_QUALIFIER vec<1, T, P> operator<<(vec<1, T, P> const & v, T scalar)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
v.x << scalar); v.x << scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator<<(T scalar, tvec<1, T, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> operator<<(T scalar, vec<1, T, P> const & v)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
scalar << v.x); scalar << v.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator<<(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2) GLM_FUNC_QUALIFIER vec<1, T, P> operator<<(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
v1.x << v2.x); v1.x << v2.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator>>(tvec<1, T, P> const & v, T scalar) GLM_FUNC_QUALIFIER vec<1, T, P> operator>>(vec<1, T, P> const & v, T scalar)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
v.x >> scalar); v.x >> scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator>>(T scalar, tvec<1, T, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> operator>>(T scalar, vec<1, T, P> const & v)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
scalar >> v.x); scalar >> v.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator>>(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2) GLM_FUNC_QUALIFIER vec<1, T, P> operator>>(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
v1.x >> v2.x); v1.x >> v2.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<1, T, P> operator~(tvec<1, T, P> const & v) GLM_FUNC_QUALIFIER vec<1, T, P> operator~(vec<1, T, P> const & v)
{ {
return tvec<1, T, P>( return vec<1, T, P>(
~v.x); ~v.x);
} }
// -- Boolean operators -- // -- Boolean operators --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER bool operator==(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2) GLM_FUNC_QUALIFIER bool operator==(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{ {
return (v1.x == v2.x); return (v1.x == v2.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER bool operator!=(tvec<1, T, P> const & v1, tvec<1, T, P> const & v2) GLM_FUNC_QUALIFIER bool operator!=(vec<1, T, P> const & v1, vec<1, T, P> const & v2)
{ {
return (v1.x != v2.x); return (v1.x != v2.x);
} }
template <precision P> template <precision P>
GLM_FUNC_QUALIFIER tvec<1, bool, P> operator&&(tvec<1, bool, P> const & v1, tvec<1, bool, P> const & v2) GLM_FUNC_QUALIFIER vec<1, bool, P> operator&&(vec<1, bool, P> const & v1, vec<1, bool, P> const & v2)
{ {
return tvec<1, bool, P>(v1.x && v2.x); return vec<1, bool, P>(v1.x && v2.x);
} }
template <precision P> template <precision P>
GLM_FUNC_QUALIFIER tvec<1, bool, P> operator||(tvec<1, bool, P> const & v1, tvec<1, bool, P> const & v2) GLM_FUNC_QUALIFIER vec<1, bool, P> operator||(vec<1, bool, P> const & v1, vec<1, bool, P> const & v2)
{ {
return tvec<1, bool, P>(v1.x || v2.x); return vec<1, bool, P>(v1.x || v2.x);
} }
}//namespace glm }//namespace glm

218
glm/detail/type_vec2.hpp
View File

@ -16,13 +16,13 @@
namespace glm namespace glm
{ {
template <typename T, precision P> template <typename T, precision P>
struct tvec<2, T, P> struct vec<2, T, P>
{ {
// -- Implementation detail -- // -- Implementation detail --
typedef T value_type; typedef T value_type;
typedef tvec type; typedef vec type;
typedef tvec<2, bool, P> bool_type; typedef vec<2, bool, P> bool_type;
// -- Data -- // -- Data --
@ -83,42 +83,42 @@ namespace glm
// -- Implicit basic constructors -- // -- Implicit basic constructors --
GLM_FUNC_DECL GLM_CONSTEXPR tvec() GLM_DEFAULT_CTOR; GLM_FUNC_DECL GLM_CONSTEXPR vec() GLM_DEFAULT_CTOR;
GLM_FUNC_DECL GLM_CONSTEXPR tvec(tvec const& v) GLM_DEFAULT; GLM_FUNC_DECL GLM_CONSTEXPR vec(vec const& v) GLM_DEFAULT;
template <precision Q> template <precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR tvec(tvec<2, T, Q> const& v); GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, T, Q> const& v);
// -- Explicit basic constructors -- // -- Explicit basic constructors --
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit tvec(ctor); GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit vec(ctor);
GLM_FUNC_DECL GLM_CONSTEXPR explicit tvec(T scalar); GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar);
GLM_FUNC_DECL GLM_CONSTEXPR tvec(T s1, T s2); GLM_FUNC_DECL GLM_CONSTEXPR vec(T s1, T s2);
// -- Conversion constructors -- // -- Conversion constructors --
/// Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) /// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B> template <typename A, typename B>
GLM_FUNC_DECL GLM_CONSTEXPR tvec(A x, B y); GLM_FUNC_DECL GLM_CONSTEXPR vec(A x, B y);
template <typename A, typename B> template <typename A, typename B>
GLM_FUNC_DECL GLM_CONSTEXPR tvec(tvec<1, A, P> const & v1, tvec<1, B, P> const & v2); GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const & v1, vec<1, B, P> const & v2);
// -- Conversion vector constructors -- // -- Conversion vector constructors --
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec(tvec<3, U, Q> const & v); GLM_FUNC_DECL GLM_CONSTEXPR 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) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec(tvec<4, U, Q> const & v); GLM_FUNC_DECL GLM_CONSTEXPR 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) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec(tvec<2, U, Q> const & v); GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<2, U, Q> const & v);
// -- Swizzle constructors -- // -- Swizzle constructors --
# if GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED) # if GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)
template <int E0, int E1> template <int E0, int E1>
GLM_FUNC_DECL tvec(detail::_swizzle<2, T, P, E0, E1,-1,-2> const& that) GLM_FUNC_DECL vec(detail::_swizzle<2, T, P, E0, E1,-1,-2> const& that)
{ {
*this = that(); *this = that();
} }
@ -126,258 +126,258 @@ namespace glm
// -- Unary arithmetic operators -- // -- Unary arithmetic operators --
GLM_FUNC_DECL tvec& operator=(tvec const & v) GLM_DEFAULT; GLM_FUNC_DECL vec& operator=(vec const & v) GLM_DEFAULT;
template <typename U> template <typename U>
GLM_FUNC_DECL tvec& operator=(tvec<2, U, P> const & v); GLM_FUNC_DECL vec& operator=(vec<2, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec& operator+=(U scalar); GLM_FUNC_DECL vec& operator+=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec& operator+=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec& operator+=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec& operator+=(tvec<2, U, P> const & v); GLM_FUNC_DECL vec& operator+=(vec<2, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec& operator-=(U scalar); GLM_FUNC_DECL vec& operator-=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec& operator-=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec& operator-=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec& operator-=(tvec<2, U, P> const & v); GLM_FUNC_DECL vec& operator-=(vec<2, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec& operator*=(U scalar); GLM_FUNC_DECL vec& operator*=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec& operator*=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec& operator*=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec& operator*=(tvec<2, U, P> const & v); GLM_FUNC_DECL vec& operator*=(vec<2, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec& operator/=(U scalar); GLM_FUNC_DECL vec& operator/=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec& operator/=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec& operator/=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec& operator/=(tvec<2, U, P> const & v); GLM_FUNC_DECL vec& operator/=(vec<2, U, P> const & v);
// -- Increment and decrement operators -- // -- Increment and decrement operators --
GLM_FUNC_DECL tvec & operator++(); GLM_FUNC_DECL vec & operator++();
GLM_FUNC_DECL tvec & operator--(); GLM_FUNC_DECL vec & operator--();
GLM_FUNC_DECL tvec operator++(int); GLM_FUNC_DECL vec operator++(int);
GLM_FUNC_DECL tvec operator--(int); GLM_FUNC_DECL vec operator--(int);
// -- Unary bit operators -- // -- Unary bit operators --
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator%=(U scalar); GLM_FUNC_DECL vec & operator%=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator%=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator%=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator%=(tvec<2, U, P> const & v); GLM_FUNC_DECL vec & operator%=(vec<2, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator&=(U scalar); GLM_FUNC_DECL vec & operator&=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator&=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator&=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator&=(tvec<2, U, P> const & v); GLM_FUNC_DECL vec & operator&=(vec<2, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator|=(U scalar); GLM_FUNC_DECL vec & operator|=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator|=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator|=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator|=(tvec<2, U, P> const & v); GLM_FUNC_DECL vec & operator|=(vec<2, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator^=(U scalar); GLM_FUNC_DECL vec & operator^=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator^=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator^=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator^=(tvec<2, U, P> const & v); GLM_FUNC_DECL vec & operator^=(vec<2, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator<<=(U scalar); GLM_FUNC_DECL vec & operator<<=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator<<=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator<<=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator<<=(tvec<2, U, P> const & v); GLM_FUNC_DECL vec & operator<<=(vec<2, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator>>=(U scalar); GLM_FUNC_DECL vec & operator>>=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator>>=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator>>=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator>>=(tvec<2, U, P> const & v); GLM_FUNC_DECL vec & operator>>=(vec<2, U, P> const & v);
}; };
// -- Unary operators -- // -- Unary operators --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator+(tvec<2, T, P> const & v); GLM_FUNC_DECL vec<2, T, P> operator+(vec<2, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator-(tvec<2, T, P> const & v); GLM_FUNC_DECL vec<2, T, P> operator-(vec<2, T, P> const & v);
// -- Binary operators -- // -- Binary operators --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator+(tvec<2, T, P> const & v, T scalar); GLM_FUNC_DECL vec<2, T, P> operator+(vec<2, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator+(tvec<2, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator+(T scalar, tvec<2, T, P> const & v); GLM_FUNC_DECL vec<2, T, P> operator+(T scalar, vec<2, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator+(tvec<1, T, P> const & v1, tvec<2, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator+(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator-(tvec<2, T, P> const & v, T scalar); GLM_FUNC_DECL vec<2, T, P> operator-(vec<2, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator-(tvec<2, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator-(T scalar, tvec<2, T, P> const & v); GLM_FUNC_DECL vec<2, T, P> operator-(T scalar, vec<2, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator-(tvec<1, T, P> const & v1, tvec<2, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator-(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator*(tvec<2, T, P> const & v, T scalar); GLM_FUNC_DECL vec<2, T, P> operator*(vec<2, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator*(tvec<2, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator*(T scalar, tvec<2, T, P> const & v); GLM_FUNC_DECL vec<2, T, P> operator*(T scalar, vec<2, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator*(tvec<1, T, P> const & v1, tvec<2, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator*(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator/(tvec<2, T, P> const & v, T scalar); GLM_FUNC_DECL vec<2, T, P> operator/(vec<2, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator/(tvec<2, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator/(T scalar, tvec<2, T, P> const & v); GLM_FUNC_DECL vec<2, T, P> operator/(T scalar, vec<2, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator/(tvec<1, T, P> const & v1, tvec<2, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator/(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator%(tvec<2, T, P> const & v, T scalar); GLM_FUNC_DECL vec<2, T, P> operator%(vec<2, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator%(tvec<2, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator%(T scalar, tvec<2, T, P> const & v); GLM_FUNC_DECL vec<2, T, P> operator%(T scalar, vec<2, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator%(tvec<1, T, P> const & v1, tvec<2, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator%(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator&(tvec<2, T, P> const & v, T scalar); GLM_FUNC_DECL vec<2, T, P> operator&(vec<2, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator&(tvec<2, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator&(T scalar, tvec<2, T, P> const & v); GLM_FUNC_DECL vec<2, T, P> operator&(T scalar, vec<2, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator&(tvec<1, T, P> const & v1, tvec<2, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator&(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator|(tvec<2, T, P> const & v, T scalar); GLM_FUNC_DECL vec<2, T, P> operator|(vec<2, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator|(tvec<2, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator|(T scalar, tvec<2, T, P> const & v); GLM_FUNC_DECL vec<2, T, P> operator|(T scalar, vec<2, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator|(tvec<1, T, P> const & v1, tvec<2, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator|(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator^(tvec<2, T, P> const & v, T scalar); GLM_FUNC_DECL vec<2, T, P> operator^(vec<2, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator^(tvec<2, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator^(T scalar, tvec<2, T, P> const & v); GLM_FUNC_DECL vec<2, T, P> operator^(T scalar, vec<2, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator^(tvec<1, T, P> const & v1, tvec<2, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator^(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator<<(tvec<2, T, P> const & v, T scalar); GLM_FUNC_DECL vec<2, T, P> operator<<(vec<2, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator<<(tvec<2, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator<<(T scalar, tvec<2, T, P> const & v); GLM_FUNC_DECL vec<2, T, P> operator<<(T scalar, vec<2, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator<<(tvec<1, T, P> const & v1, tvec<2, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator<<(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator>>(tvec<2, T, P> const & v, T scalar); GLM_FUNC_DECL vec<2, T, P> operator>>(vec<2, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator>>(tvec<2, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator>>(T scalar, tvec<2, T, P> const & v); GLM_FUNC_DECL vec<2, T, P> operator>>(T scalar, vec<2, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator>>(tvec<1, T, P> const & v1, tvec<2, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator>>(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<2, T, P> operator~(tvec<2, T, P> const & v); GLM_FUNC_DECL vec<2, T, P> operator~(vec<2, T, P> const & v);
// -- Boolean operators -- // -- Boolean operators --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL bool operator==(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL bool operator!=(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2); GLM_FUNC_DECL bool operator!=(vec<2, T, P> const & v1, vec<2, T, P> const & v2);
template <precision P> template <precision P>
GLM_FUNC_DECL tvec<2, bool, P> operator&&(tvec<2, bool, P> const & v1, tvec<2, bool, P> const & v2); GLM_FUNC_DECL vec<2, bool, P> operator&&(vec<2, bool, P> const & v1, vec<2, bool, P> const & v2);
template <precision P> template <precision P>
GLM_FUNC_DECL tvec<2, bool, P> operator||(tvec<2, bool, P> const & v1, tvec<2, bool, P> const & v2); GLM_FUNC_DECL vec<2, bool, P> operator||(vec<2, bool, P> const & v1, vec<2, bool, P> const & v2);
}//namespace glm }//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE #ifndef GLM_EXTERNAL_TEMPLATE

324
glm/detail/type_vec2.inl
View File

@ -7,7 +7,7 @@ namespace glm
# if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT) # if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec<2, T, P>::tvec() GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, P>::vec()
# ifndef GLM_FORCE_NO_CTOR_INIT # ifndef GLM_FORCE_NO_CTOR_INIT
: x(0), y(0) : x(0), y(0)
# endif # endif
@ -16,30 +16,30 @@ namespace glm
# if !GLM_HAS_DEFAULTED_FUNCTIONS # if !GLM_HAS_DEFAULTED_FUNCTIONS
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec<2, T, P>::tvec(tvec<2, T, P> const & v) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, P>::vec(vec<2, T, P> const & v)
: x(v.x), y(v.y) : x(v.x), y(v.y)
{} {}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS # endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template <typename T, precision P> template <typename T, precision P>
template <precision Q> template <precision Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec<2, T, P>::tvec(tvec<2, T, Q> const & v) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, P>::vec(vec<2, T, Q> const & v)
: x(v.x), y(v.y) : x(v.x), y(v.y)
{} {}
// -- Explicit basic constructors -- // -- Explicit basic constructors --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR tvec<2, T, P>::tvec(ctor) GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR vec<2, T, P>::vec(ctor)
{} {}
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec<2, T, P>::tvec(T scalar) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, P>::vec(T scalar)
: x(scalar), y(scalar) : x(scalar), y(scalar)
{} {}
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec<2, T, P>::tvec(T s1, T s2) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, P>::vec(T s1, T s2)
: x(s1), y(s2) : x(s1), y(s2)
{} {}
@ -47,14 +47,14 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename A, typename B> template <typename A, typename B>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec<2, T, P>::tvec(A a, B b) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, P>::vec(A a, B b)
: x(static_cast<T>(a)) : x(static_cast<T>(a))
, y(static_cast<T>(b)) , y(static_cast<T>(b))
{} {}
template <typename T, precision P> template <typename T, precision P>
template <typename A, typename B> template <typename A, typename B>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec<2, T, P>::tvec(tvec<1, A, P> const & a, tvec<1, B, P> const & b) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, P>::vec(vec<1, A, P> const & a, vec<1, B, P> const & b)
: x(static_cast<T>(a.x)) : x(static_cast<T>(a.x))
, y(static_cast<T>(b.x)) , y(static_cast<T>(b.x))
{} {}
@ -63,21 +63,21 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U, precision Q> template <typename U, precision Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec<2, T, P>::tvec(tvec<2, U, Q> const & v) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, P>::vec(vec<2, U, Q> const & v)
: x(static_cast<T>(v.x)) : x(static_cast<T>(v.x))
, y(static_cast<T>(v.y)) , y(static_cast<T>(v.y))
{} {}
template <typename T, precision P> template <typename T, precision P>
template <typename U, precision Q> template <typename U, precision Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec<2, T, P>::tvec(tvec<3, U, Q> const & v) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, P>::vec(vec<3, U, Q> const & v)
: x(static_cast<T>(v.x)) : x(static_cast<T>(v.x))
, y(static_cast<T>(v.y)) , y(static_cast<T>(v.y))
{} {}
template <typename T, precision P> template <typename T, precision P>
template <typename U, precision Q> template <typename U, precision Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR tvec<2, T, P>::tvec(tvec<4, U, Q> const & v) GLM_FUNC_QUALIFIER GLM_CONSTEXPR vec<2, T, P>::vec(vec<4, U, Q> const & v)
: x(static_cast<T>(v.x)) : x(static_cast<T>(v.x))
, y(static_cast<T>(v.y)) , y(static_cast<T>(v.y))
{} {}
@ -85,14 +85,14 @@ namespace glm
// -- Component accesses -- // -- Component accesses --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER T & tvec<2, T, P>::operator[](typename tvec<2, T, P>::length_type i) GLM_FUNC_QUALIFIER T & vec<2, T, P>::operator[](typename vec<2, T, P>::length_type i)
{ {
assert(i >= 0 && i < this->length()); assert(i >= 0 && i < this->length());
return (&x)[i]; return (&x)[i];
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER T const & tvec<2, T, P>::operator[](typename tvec<2, T, P>::length_type i) const 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()); assert(i >= 0 && i < this->length());
return (&x)[i]; return (&x)[i];
@ -102,7 +102,7 @@ namespace glm
# if !GLM_HAS_DEFAULTED_FUNCTIONS # if !GLM_HAS_DEFAULTED_FUNCTIONS
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator=(tvec<2, T, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator=(vec<2, T, P> const & v)
{ {
this->x = v.x; this->x = v.x;
this->y = v.y; this->y = v.y;
@ -112,7 +112,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator=(tvec<2, U, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator=(vec<2, U, P> const & v)
{ {
this->x = static_cast<T>(v.x); this->x = static_cast<T>(v.x);
this->y = static_cast<T>(v.y); this->y = static_cast<T>(v.y);
@ -121,7 +121,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator+=(U scalar) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator+=(U scalar)
{ {
this->x += static_cast<T>(scalar); this->x += static_cast<T>(scalar);
this->y += static_cast<T>(scalar); this->y += static_cast<T>(scalar);
@ -130,7 +130,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator+=(tvec<1, U, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator+=(vec<1, U, P> const & v)
{ {
this->x += static_cast<T>(v.x); this->x += static_cast<T>(v.x);
this->y += static_cast<T>(v.x); this->y += static_cast<T>(v.x);
@ -139,7 +139,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator+=(tvec<2, U, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator+=(vec<2, U, P> const & v)
{ {
this->x += static_cast<T>(v.x); this->x += static_cast<T>(v.x);
this->y += static_cast<T>(v.y); this->y += static_cast<T>(v.y);
@ -148,7 +148,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator-=(U scalar) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator-=(U scalar)
{ {
this->x -= static_cast<T>(scalar); this->x -= static_cast<T>(scalar);
this->y -= static_cast<T>(scalar); this->y -= static_cast<T>(scalar);
@ -157,7 +157,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator-=(tvec<1, U, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator-=(vec<1, U, P> const & v)
{ {
this->x -= static_cast<T>(v.x); this->x -= static_cast<T>(v.x);
this->y -= static_cast<T>(v.x); this->y -= static_cast<T>(v.x);
@ -166,7 +166,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator-=(tvec<2, U, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator-=(vec<2, U, P> const & v)
{ {
this->x -= static_cast<T>(v.x); this->x -= static_cast<T>(v.x);
this->y -= static_cast<T>(v.y); this->y -= static_cast<T>(v.y);
@ -175,7 +175,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator*=(U scalar) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator*=(U scalar)
{ {
this->x *= static_cast<T>(scalar); this->x *= static_cast<T>(scalar);
this->y *= static_cast<T>(scalar); this->y *= static_cast<T>(scalar);
@ -184,7 +184,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator*=(tvec<1, U, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator*=(vec<1, U, P> const & v)
{ {
this->x *= static_cast<T>(v.x); this->x *= static_cast<T>(v.x);
this->y *= static_cast<T>(v.x); this->y *= static_cast<T>(v.x);
@ -193,7 +193,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator*=(tvec<2, U, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator*=(vec<2, U, P> const & v)
{ {
this->x *= static_cast<T>(v.x); this->x *= static_cast<T>(v.x);
this->y *= static_cast<T>(v.y); this->y *= static_cast<T>(v.y);
@ -202,7 +202,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator/=(U scalar) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator/=(U scalar)
{ {
this->x /= static_cast<T>(scalar); this->x /= static_cast<T>(scalar);
this->y /= static_cast<T>(scalar); this->y /= static_cast<T>(scalar);
@ -211,7 +211,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator/=(tvec<1, U, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator/=(vec<1, U, P> const & v)
{ {
this->x /= static_cast<T>(v.x); this->x /= static_cast<T>(v.x);
this->y /= static_cast<T>(v.x); this->y /= static_cast<T>(v.x);
@ -220,7 +220,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator/=(tvec<2, U, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator/=(vec<2, U, P> const & v)
{ {
this->x /= static_cast<T>(v.x); this->x /= static_cast<T>(v.x);
this->y /= static_cast<T>(v.y); this->y /= static_cast<T>(v.y);
@ -230,7 +230,7 @@ namespace glm
// -- Increment and decrement operators -- // -- Increment and decrement operators --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator++() GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator++()
{ {
++this->x; ++this->x;
++this->y; ++this->y;
@ -238,7 +238,7 @@ namespace glm
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator--() GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator--()
{ {
--this->x; --this->x;
--this->y; --this->y;
@ -246,17 +246,17 @@ namespace glm
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> tvec<2, T, P>::operator++(int) GLM_FUNC_QUALIFIER vec<2, T, P> vec<2, T, P>::operator++(int)
{ {
tvec<2, T, P> Result(*this); vec<2, T, P> Result(*this);
++*this; ++*this;
return Result; return Result;
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> tvec<2, T, P>::operator--(int) GLM_FUNC_QUALIFIER vec<2, T, P> vec<2, T, P>::operator--(int)
{ {
tvec<2, T, P> Result(*this); vec<2, T, P> Result(*this);
--*this; --*this;
return Result; return Result;
} }
@ -265,7 +265,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator%=(U scalar) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator%=(U scalar)
{ {
this->x %= static_cast<T>(scalar); this->x %= static_cast<T>(scalar);
this->y %= static_cast<T>(scalar); this->y %= static_cast<T>(scalar);
@ -274,7 +274,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator%=(tvec<1, U, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator%=(vec<1, U, P> const & v)
{ {
this->x %= static_cast<T>(v.x); this->x %= static_cast<T>(v.x);
this->y %= static_cast<T>(v.x); this->y %= static_cast<T>(v.x);
@ -283,7 +283,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator%=(tvec<2, U, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator%=(vec<2, U, P> const & v)
{ {
this->x %= static_cast<T>(v.x); this->x %= static_cast<T>(v.x);
this->y %= static_cast<T>(v.y); this->y %= static_cast<T>(v.y);
@ -292,7 +292,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator&=(U scalar) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator&=(U scalar)
{ {
this->x &= static_cast<T>(scalar); this->x &= static_cast<T>(scalar);
this->y &= static_cast<T>(scalar); this->y &= static_cast<T>(scalar);
@ -301,7 +301,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator&=(tvec<1, U, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator&=(vec<1, U, P> const & v)
{ {
this->x &= static_cast<T>(v.x); this->x &= static_cast<T>(v.x);
this->y &= static_cast<T>(v.x); this->y &= static_cast<T>(v.x);
@ -310,7 +310,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator&=(tvec<2, U, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator&=(vec<2, U, P> const & v)
{ {
this->x &= static_cast<T>(v.x); this->x &= static_cast<T>(v.x);
this->y &= static_cast<T>(v.y); this->y &= static_cast<T>(v.y);
@ -319,7 +319,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator|=(U scalar) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator|=(U scalar)
{ {
this->x |= static_cast<T>(scalar); this->x |= static_cast<T>(scalar);
this->y |= static_cast<T>(scalar); this->y |= static_cast<T>(scalar);
@ -328,7 +328,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator|=(tvec<1, U, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator|=(vec<1, U, P> const & v)
{ {
this->x |= static_cast<T>(v.x); this->x |= static_cast<T>(v.x);
this->y |= static_cast<T>(v.x); this->y |= static_cast<T>(v.x);
@ -337,7 +337,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator|=(tvec<2, U, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator|=(vec<2, U, P> const & v)
{ {
this->x |= static_cast<T>(v.x); this->x |= static_cast<T>(v.x);
this->y |= static_cast<T>(v.y); this->y |= static_cast<T>(v.y);
@ -346,7 +346,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator^=(U scalar) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator^=(U scalar)
{ {
this->x ^= static_cast<T>(scalar); this->x ^= static_cast<T>(scalar);
this->y ^= static_cast<T>(scalar); this->y ^= static_cast<T>(scalar);
@ -355,7 +355,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator^=(tvec<1, U, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator^=(vec<1, U, P> const & v)
{ {
this->x ^= static_cast<T>(v.x); this->x ^= static_cast<T>(v.x);
this->y ^= static_cast<T>(v.x); this->y ^= static_cast<T>(v.x);
@ -364,7 +364,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator^=(tvec<2, U, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator^=(vec<2, U, P> const & v)
{ {
this->x ^= static_cast<T>(v.x); this->x ^= static_cast<T>(v.x);
this->y ^= static_cast<T>(v.y); this->y ^= static_cast<T>(v.y);
@ -373,7 +373,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator<<=(U scalar) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator<<=(U scalar)
{ {
this->x <<= static_cast<T>(scalar); this->x <<= static_cast<T>(scalar);
this->y <<= static_cast<T>(scalar); this->y <<= static_cast<T>(scalar);
@ -382,7 +382,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator<<=(tvec<1, U, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator<<=(vec<1, U, P> const & v)
{ {
this->x <<= static_cast<T>(v.x); this->x <<= static_cast<T>(v.x);
this->y <<= static_cast<T>(v.x); this->y <<= static_cast<T>(v.x);
@ -391,7 +391,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator<<=(tvec<2, U, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator<<=(vec<2, U, P> const & v)
{ {
this->x <<= static_cast<T>(v.x); this->x <<= static_cast<T>(v.x);
this->y <<= static_cast<T>(v.y); this->y <<= static_cast<T>(v.y);
@ -400,7 +400,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator>>=(U scalar) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator>>=(U scalar)
{ {
this->x >>= static_cast<T>(scalar); this->x >>= static_cast<T>(scalar);
this->y >>= static_cast<T>(scalar); this->y >>= static_cast<T>(scalar);
@ -409,7 +409,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator>>=(tvec<1, U, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator>>=(vec<1, U, P> const & v)
{ {
this->x >>= static_cast<T>(v.x); this->x >>= static_cast<T>(v.x);
this->y >>= static_cast<T>(v.x); this->y >>= static_cast<T>(v.x);
@ -418,7 +418,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec<2, T, P> & tvec<2, T, P>::operator>>=(tvec<2, U, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> & vec<2, T, P>::operator>>=(vec<2, U, P> const & v)
{ {
this->x >>= static_cast<T>(v.x); this->x >>= static_cast<T>(v.x);
this->y >>= static_cast<T>(v.y); this->y >>= static_cast<T>(v.y);
@ -428,15 +428,15 @@ namespace glm
// -- Unary arithmetic operators -- // -- Unary arithmetic operators --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator+(tvec<2, T, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> operator+(vec<2, T, P> const & v)
{ {
return v; return v;
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator-(tvec<2, T, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> operator-(vec<2, T, P> const & v)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
-v.x, -v.x,
-v.y); -v.y);
} }
@ -444,161 +444,161 @@ namespace glm
// -- Binary arithmetic operators -- // -- Binary arithmetic operators --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator+(tvec<2, T, P> const & v, T scalar) GLM_FUNC_QUALIFIER vec<2, T, P> operator+(vec<2, T, P> const & v, T scalar)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v.x + scalar, v.x + scalar,
v.y + scalar); v.y + scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator+(tvec<2, T, P> const & v1, tvec<1, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator+(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x + v2.x, v1.x + v2.x,
v1.y + v2.x); v1.y + v2.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator+(T scalar, tvec<2, T, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> operator+(T scalar, vec<2, T, P> const & v)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
scalar + v.x, scalar + v.x,
scalar + v.y); scalar + v.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator+(tvec<1, T, P> const & v1, tvec<2, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator+(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x + v2.x, v1.x + v2.x,
v1.x + v2.y); v1.x + v2.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator+(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator+(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x + v2.x, v1.x + v2.x,
v1.y + v2.y); v1.y + v2.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator-(tvec<2, T, P> const & v, T scalar) GLM_FUNC_QUALIFIER vec<2, T, P> operator-(vec<2, T, P> const & v, T scalar)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v.x - scalar, v.x - scalar,
v.y - scalar); v.y - scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator-(tvec<2, T, P> const & v1, tvec<1, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator-(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x - v2.x, v1.x - v2.x,
v1.y - v2.x); v1.y - v2.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator-(T scalar, tvec<2, T, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> operator-(T scalar, vec<2, T, P> const & v)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
scalar - v.x, scalar - v.x,
scalar - v.y); scalar - v.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator-(tvec<1, T, P> const & v1, tvec<2, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator-(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x - v2.x, v1.x - v2.x,
v1.x - v2.y); v1.x - v2.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator-(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator-(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x - v2.x, v1.x - v2.x,
v1.y - v2.y); v1.y - v2.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator*(tvec<2, T, P> const & v, T scalar) GLM_FUNC_QUALIFIER vec<2, T, P> operator*(vec<2, T, P> const & v, T scalar)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v.x * scalar, v.x * scalar,
v.y * scalar); v.y * scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator*(tvec<2, T, P> const & v1, tvec<1, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator*(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x * v2.x, v1.x * v2.x,
v1.y * v2.x); v1.y * v2.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator*(T scalar, tvec<2, T, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> operator*(T scalar, vec<2, T, P> const & v)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
scalar * v.x, scalar * v.x,
scalar * v.y); scalar * v.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator*(tvec<1, T, P> const & v1, tvec<2, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator*(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x * v2.x, v1.x * v2.x,
v1.x * v2.y); v1.x * v2.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator*(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator*(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x * v2.x, v1.x * v2.x,
v1.y * v2.y); v1.y * v2.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator/(tvec<2, T, P> const & v, T scalar) GLM_FUNC_QUALIFIER vec<2, T, P> operator/(vec<2, T, P> const & v, T scalar)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v.x / scalar, v.x / scalar,
v.y / scalar); v.y / scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator/(tvec<2, T, P> const & v1, tvec<1, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator/(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x / v2.x, v1.x / v2.x,
v1.y / v2.x); v1.y / v2.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator/(T scalar, tvec<2, T, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> operator/(T scalar, vec<2, T, P> const & v)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
scalar / v.x, scalar / v.x,
scalar / v.y); scalar / v.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator/(tvec<1, T, P> const & v1, tvec<2, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator/(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x / v2.x, v1.x / v2.x,
v1.x / v2.y); v1.x / v2.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator/(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator/(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x / v2.x, v1.x / v2.x,
v1.y / v2.y); v1.y / v2.y);
} }
@ -606,249 +606,249 @@ namespace glm
// -- Binary bit operators -- // -- Binary bit operators --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator%(tvec<2, T, P> const & v, T scalar) GLM_FUNC_QUALIFIER vec<2, T, P> operator%(vec<2, T, P> const & v, T scalar)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v.x % scalar, v.x % scalar,
v.y % scalar); v.y % scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator%(tvec<2, T, P> const & v1, tvec<1, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator%(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x % v2.x, v1.x % v2.x,
v1.y % v2.x); v1.y % v2.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator%(T scalar, tvec<2, T, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> operator%(T scalar, vec<2, T, P> const & v)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
scalar % v.x, scalar % v.x,
scalar % v.y); scalar % v.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator%(tvec<1, T, P> const & v1, tvec<2, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator%(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x % v2.x, v1.x % v2.x,
v1.x % v2.y); v1.x % v2.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator%(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator%(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x % v2.x, v1.x % v2.x,
v1.y % v2.y); v1.y % v2.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator&(tvec<2, T, P> const & v, T scalar) GLM_FUNC_QUALIFIER vec<2, T, P> operator&(vec<2, T, P> const & v, T scalar)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v.x & scalar, v.x & scalar,
v.y & scalar); v.y & scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator&(tvec<2, T, P> const & v1, tvec<1, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator&(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x & v2.x, v1.x & v2.x,
v1.y & v2.x); v1.y & v2.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator&(T scalar, tvec<2, T, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> operator&(T scalar, vec<2, T, P> const & v)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
scalar & v.x, scalar & v.x,
scalar & v.y); scalar & v.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator&(tvec<1, T, P> const & v1, tvec<2, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator&(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x & v2.x, v1.x & v2.x,
v1.x & v2.y); v1.x & v2.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator&(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator&(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x & v2.x, v1.x & v2.x,
v1.y & v2.y); v1.y & v2.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator|(tvec<2, T, P> const & v, T scalar) GLM_FUNC_QUALIFIER vec<2, T, P> operator|(vec<2, T, P> const & v, T scalar)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v.x | scalar, v.x | scalar,
v.y | scalar); v.y | scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator|(tvec<2, T, P> const & v1, tvec<1, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator|(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x | v2.x, v1.x | v2.x,
v1.y | v2.x); v1.y | v2.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator|(T scalar, tvec<2, T, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> operator|(T scalar, vec<2, T, P> const & v)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
scalar | v.x, scalar | v.x,
scalar | v.y); scalar | v.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator|(tvec<1, T, P> const & v1, tvec<2, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator|(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x | v2.x, v1.x | v2.x,
v1.x | v2.y); v1.x | v2.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator|(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator|(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x | v2.x, v1.x | v2.x,
v1.y | v2.y); v1.y | v2.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator^(tvec<2, T, P> const & v, T scalar) GLM_FUNC_QUALIFIER vec<2, T, P> operator^(vec<2, T, P> const & v, T scalar)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v.x ^ scalar, v.x ^ scalar,
v.y ^ scalar); v.y ^ scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator^(tvec<2, T, P> const & v1, tvec<1, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator^(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x ^ v2.x, v1.x ^ v2.x,
v1.y ^ v2.x); v1.y ^ v2.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator^(T scalar, tvec<2, T, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> operator^(T scalar, vec<2, T, P> const & v)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
scalar ^ v.x, scalar ^ v.x,
scalar ^ v.y); scalar ^ v.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator^(tvec<1, T, P> const & v1, tvec<2, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator^(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x ^ v2.x, v1.x ^ v2.x,
v1.x ^ v2.y); v1.x ^ v2.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator^(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator^(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x ^ v2.x, v1.x ^ v2.x,
v1.y ^ v2.y); v1.y ^ v2.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator<<(tvec<2, T, P> const & v, T scalar) GLM_FUNC_QUALIFIER vec<2, T, P> operator<<(vec<2, T, P> const & v, T scalar)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v.x << scalar, v.x << scalar,
v.y << scalar); v.y << scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator<<(tvec<2, T, P> const & v1, tvec<1, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator<<(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x << v2.x, v1.x << v2.x,
v1.y << v2.x); v1.y << v2.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator<<(T scalar, tvec<2, T, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> operator<<(T scalar, vec<2, T, P> const & v)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
scalar << v.x, scalar << v.x,
scalar << v.y); scalar << v.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator<<(tvec<1, T, P> const & v1, tvec<2, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator<<(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x << v2.x, v1.x << v2.x,
v1.x << v2.y); v1.x << v2.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator<<(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator<<(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x << v2.x, v1.x << v2.x,
v1.y << v2.y); v1.y << v2.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator>>(tvec<2, T, P> const & v, T scalar) GLM_FUNC_QUALIFIER vec<2, T, P> operator>>(vec<2, T, P> const & v, T scalar)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v.x >> scalar, v.x >> scalar,
v.y >> scalar); v.y >> scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator>>(tvec<2, T, P> const & v1, tvec<1, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator>>(vec<2, T, P> const & v1, vec<1, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x >> v2.x, v1.x >> v2.x,
v1.y >> v2.x); v1.y >> v2.x);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator>>(T scalar, tvec<2, T, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> operator>>(T scalar, vec<2, T, P> const & v)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
scalar >> v.x, scalar >> v.x,
scalar >> v.y); scalar >> v.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator>>(tvec<1, T, P> const & v1, tvec<2, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator>>(vec<1, T, P> const & v1, vec<2, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x >> v2.x, v1.x >> v2.x,
v1.x >> v2.y); v1.x >> v2.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator>>(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2) GLM_FUNC_QUALIFIER vec<2, T, P> operator>>(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
v1.x >> v2.x, v1.x >> v2.x,
v1.y >> v2.y); v1.y >> v2.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<2, T, P> operator~(tvec<2, T, P> const & v) GLM_FUNC_QUALIFIER vec<2, T, P> operator~(vec<2, T, P> const & v)
{ {
return tvec<2, T, P>( return vec<2, T, P>(
~v.x, ~v.x,
~v.y); ~v.y);
} }
@ -856,26 +856,26 @@ namespace glm
// -- Boolean operators -- // -- Boolean operators --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER bool operator==(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2) GLM_FUNC_QUALIFIER bool operator==(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{ {
return (v1.x == v2.x) && (v1.y == v2.y); return (v1.x == v2.x) && (v1.y == v2.y);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER bool operator!=(tvec<2, T, P> const & v1, tvec<2, T, P> const & v2) GLM_FUNC_QUALIFIER bool operator!=(vec<2, T, P> const & v1, vec<2, T, P> const & v2)
{ {
return (v1.x != v2.x) || (v1.y != v2.y); return (v1.x != v2.x) || (v1.y != v2.y);
} }
template <precision P> template <precision P>
GLM_FUNC_QUALIFIER tvec<2, bool, P> operator&&(tvec<2, bool, P> const & v1, tvec<2, bool, P> const & v2) GLM_FUNC_QUALIFIER vec<2, bool, P> operator&&(vec<2, bool, P> const & v1, vec<2, bool, P> const & v2)
{ {
return tvec<2, bool, P>(v1.x && v2.x, v1.y && v2.y); return vec<2, bool, P>(v1.x && v2.x, v1.y && v2.y);
} }
template <precision P> template <precision P>
GLM_FUNC_QUALIFIER tvec<2, bool, P> operator||(tvec<2, bool, P> const & v1, tvec<2, bool, P> const & v2) GLM_FUNC_QUALIFIER vec<2, bool, P> operator||(vec<2, bool, P> const & v1, vec<2, bool, P> const & v2)
{ {
return tvec<2, bool, P>(v1.x || v2.x, v1.y || v2.y); return vec<2, bool, P>(v1.x || v2.x, v1.y || v2.y);
} }
}//namespace glm }//namespace glm

230
glm/detail/type_vec3.hpp
View File

@ -16,13 +16,13 @@
namespace glm namespace glm
{ {
template <typename T, precision P> template <typename T, precision P>
struct tvec<3, T, P> struct vec<3, T, P>
{ {
// -- Implementation detail -- // -- Implementation detail --
typedef T value_type; typedef T value_type;
typedef tvec type; typedef vec type;
typedef tvec<3, bool, P> bool_type; typedef vec<3, bool, P> bool_type;
// -- Data -- // -- Data --
@ -83,322 +83,322 @@ namespace glm
// -- Implicit basic constructors -- // -- Implicit basic constructors --
GLM_FUNC_DECL GLM_CONSTEXPR tvec() GLM_DEFAULT_CTOR; GLM_FUNC_DECL GLM_CONSTEXPR vec() GLM_DEFAULT_CTOR;
GLM_FUNC_DECL GLM_CONSTEXPR tvec(tvec const & v) GLM_DEFAULT; GLM_FUNC_DECL GLM_CONSTEXPR vec(vec const & v) GLM_DEFAULT;
template <precision Q> template <precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR tvec(tvec<3, T, Q> const & v); GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<3, T, Q> const & v);
// -- Explicit basic constructors -- // -- Explicit basic constructors --
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit tvec(ctor); GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit vec(ctor);
GLM_FUNC_DECL GLM_CONSTEXPR explicit tvec(T scalar); GLM_FUNC_DECL GLM_CONSTEXPR explicit vec(T scalar);
GLM_FUNC_DECL GLM_CONSTEXPR tvec(T a, T b, T c); GLM_FUNC_DECL GLM_CONSTEXPR vec(T a, T b, T c);
// -- Conversion scalar constructors -- // -- Conversion scalar constructors --
/// Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) /// Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C> template <typename A, typename B, typename C>
GLM_FUNC_DECL GLM_CONSTEXPR tvec(A a, B b, C c); GLM_FUNC_DECL GLM_CONSTEXPR vec(A a, B b, C c);
template <typename A, typename B, typename C> template <typename A, typename B, typename C>
GLM_FUNC_DECL GLM_CONSTEXPR tvec(tvec<1, A, P> const & a, tvec<1, B, P> const & b, tvec<1, C, P> const & c); GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, P> const & a, vec<1, B, P> const & b, vec<1, C, P> const & c);
// -- Conversion vector constructors -- // -- Conversion vector constructors --
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR tvec(tvec<2, A, Q> const & a, B b); GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, Q> const & a, B b);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR tvec(tvec<2, A, Q> const & a, tvec<1, B, Q> const & b); GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, Q> const & a, vec<1, B, Q> const & b);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR tvec(A a, tvec<2, B, Q> const & b); GLM_FUNC_DECL GLM_CONSTEXPR vec(A a, vec<2, B, Q> const & b);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR tvec(tvec<1, A, Q> const & a, tvec<2, B, Q> const & b); GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, Q> const & a, vec<2, B, Q> const & b);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec(tvec<4, U, Q> const & v); GLM_FUNC_DECL GLM_CONSTEXPR 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) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec(tvec<3, U, Q> const & v); GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<3, U, Q> const & v);
// -- Swizzle constructors -- // -- Swizzle constructors --
# if GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED) # if GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)
template <int E0, int E1, int E2> template <int E0, int E1, int E2>
GLM_FUNC_DECL tvec(detail::_swizzle<3, T, P, E0, E1, E2, -1> const & that) GLM_FUNC_DECL vec(detail::_swizzle<3, T, P, E0, E1, E2, -1> const & that)
{ {
*this = that(); *this = that();
} }
template <int E0, int E1> template <int E0, int E1>
GLM_FUNC_DECL tvec(detail::_swizzle<2, T, P, E0, E1, -1, -2> const & v, T const & scalar) GLM_FUNC_DECL vec(detail::_swizzle<2, T, P, E0, E1, -1, -2> const & v, T const & scalar)
{ {
*this = tvec(v(), scalar); *this = vec(v(), scalar);
} }
template <int E0, int E1> template <int E0, int E1>
GLM_FUNC_DECL tvec(T const & scalar, detail::_swizzle<2, T, P, E0, E1, -1, -2> const & v) GLM_FUNC_DECL vec(T const & scalar, detail::_swizzle<2, T, P, E0, E1, -1, -2> const & v)
{ {
*this = tvec(scalar, v()); *this = vec(scalar, v());
} }
# endif// GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED) # endif// GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)
// -- Unary arithmetic operators -- // -- Unary arithmetic operators --
GLM_FUNC_DECL tvec & operator=(tvec const & v) GLM_DEFAULT; GLM_FUNC_DECL vec & operator=(vec const & v) GLM_DEFAULT;
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator=(tvec<3, U, P> const & v); GLM_FUNC_DECL vec & operator=(vec<3, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator+=(U scalar); GLM_FUNC_DECL vec & operator+=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator+=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator+=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator+=(tvec<3, U, P> const & v); GLM_FUNC_DECL vec & operator+=(vec<3, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator-=(U scalar); GLM_FUNC_DECL vec & operator-=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator-=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator-=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator-=(tvec<3, U, P> const & v); GLM_FUNC_DECL vec & operator-=(vec<3, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator*=(U scalar); GLM_FUNC_DECL vec & operator*=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator*=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator*=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator*=(tvec<3, U, P> const & v); GLM_FUNC_DECL vec & operator*=(vec<3, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator/=(U scalar); GLM_FUNC_DECL vec & operator/=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator/=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator/=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator/=(tvec<3, U, P> const & v); GLM_FUNC_DECL vec & operator/=(vec<3, U, P> const & v);
// -- Increment and decrement operators -- // -- Increment and decrement operators --
GLM_FUNC_DECL tvec & operator++(); GLM_FUNC_DECL vec & operator++();
GLM_FUNC_DECL tvec & operator--(); GLM_FUNC_DECL vec & operator--();
GLM_FUNC_DECL tvec operator++(int); GLM_FUNC_DECL vec operator++(int);
GLM_FUNC_DECL tvec operator--(int); GLM_FUNC_DECL vec operator--(int);
// -- Unary bit operators -- // -- Unary bit operators --
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator%=(U scalar); GLM_FUNC_DECL vec & operator%=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator%=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator%=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator%=(tvec<3, U, P> const & v); GLM_FUNC_DECL vec & operator%=(vec<3, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator&=(U scalar); GLM_FUNC_DECL vec & operator&=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator&=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator&=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator&=(tvec<3, U, P> const & v); GLM_FUNC_DECL vec & operator&=(vec<3, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator|=(U scalar); GLM_FUNC_DECL vec & operator|=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator|=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator|=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator|=(tvec<3, U, P> const & v); GLM_FUNC_DECL vec & operator|=(vec<3, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator^=(U scalar); GLM_FUNC_DECL vec & operator^=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator^=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator^=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator^=(tvec<3, U, P> const & v); GLM_FUNC_DECL vec & operator^=(vec<3, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator<<=(U scalar); GLM_FUNC_DECL vec & operator<<=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator<<=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator<<=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator<<=(tvec<3, U, P> const & v); GLM_FUNC_DECL vec & operator<<=(vec<3, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator>>=(U scalar); GLM_FUNC_DECL vec & operator>>=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator>>=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec & operator>>=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec & operator>>=(tvec<3, U, P> const & v); GLM_FUNC_DECL vec & operator>>=(vec<3, U, P> const & v);
}; };
// -- Unary operators -- // -- Unary operators --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator+(tvec<3, T, P> const & v); GLM_FUNC_DECL vec<3, T, P> operator+(vec<3, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator-(tvec<3, T, P> const & v); GLM_FUNC_DECL vec<3, T, P> operator-(vec<3, T, P> const & v);
// -- Binary operators -- // -- Binary operators --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator+(tvec<3, T, P> const & v, T scalar); GLM_FUNC_DECL vec<3, T, P> operator+(vec<3, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator+(tvec<3, T, P> const & v, tvec<1, T, P> const & scalar); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator+(T scalar, tvec<3, T, P> const & v); GLM_FUNC_DECL vec<3, T, P> operator+(T scalar, vec<3, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator+(tvec<1, T, P> const & v1, tvec<3, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator+(tvec<3, T, P> const & v1, tvec<3, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator-(tvec<3, T, P> const & v, T scalar); GLM_FUNC_DECL vec<3, T, P> operator-(vec<3, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator-(tvec<3, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator-(T scalar, tvec<3, T, P> const & v); GLM_FUNC_DECL vec<3, T, P> operator-(T scalar, vec<3, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator-(tvec<1, T, P> const & v1, tvec<3, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator-(tvec<3, T, P> const & v1, tvec<3, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator*(tvec<3, T, P> const & v, T scalar); GLM_FUNC_DECL vec<3, T, P> operator*(vec<3, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator*(tvec<3, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator*(T scalar, tvec<3, T, P> const & v); GLM_FUNC_DECL vec<3, T, P> operator*(T scalar, vec<3, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator*(tvec<1, T, P> const & v1, tvec<3, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator*(tvec<3, T, P> const & v1, tvec<3, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator/(tvec<3, T, P> const & v, T scalar); GLM_FUNC_DECL vec<3, T, P> operator/(vec<3, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator/(tvec<3, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator/(T scalar, tvec<3, T, P> const & v); GLM_FUNC_DECL vec<3, T, P> operator/(T scalar, vec<3, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator/(tvec<1, T, P> const & v1, tvec<3, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator/(tvec<3, T, P> const & v1, tvec<3, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator%(tvec<3, T, P> const & v, T scalar); GLM_FUNC_DECL vec<3, T, P> operator%(vec<3, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator%(tvec<3, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator%(T const & scalar, tvec<3, T, P> const & v); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator%(tvec<1, T, P> const & v1, tvec<3, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator%(tvec<3, T, P> const & v1, tvec<3, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator&(tvec<3, T, P> const & v1, T scalar); GLM_FUNC_DECL vec<3, T, P> operator&(vec<3, T, P> const & v1, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator&(tvec<3, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator&(T scalar, tvec<3, T, P> const & v); GLM_FUNC_DECL vec<3, T, P> operator&(T scalar, vec<3, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator&(tvec<1, T, P> const & v1, tvec<3, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator&(tvec<3, T, P> const & v1, tvec<3, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator|(tvec<3, T, P> const & v, T scalar); GLM_FUNC_DECL vec<3, T, P> operator|(vec<3, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator|(tvec<3, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator|(T scalar, tvec<3, T, P> const & v); GLM_FUNC_DECL vec<3, T, P> operator|(T scalar, vec<3, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator|(tvec<1, T, P> const & v1, tvec<3, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator|(tvec<3, T, P> const & v1, tvec<3, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator^(tvec<3, T, P> const & v, T scalar); GLM_FUNC_DECL vec<3, T, P> operator^(vec<3, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator^(tvec<3, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator^(T scalar, tvec<3, T, P> const & v); GLM_FUNC_DECL vec<3, T, P> operator^(T scalar, vec<3, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator^(tvec<1, T, P> const & v1, tvec<3, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator^(tvec<3, T, P> const & v1, tvec<3, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator<<(tvec<3, T, P> const & v, T scalar); GLM_FUNC_DECL vec<3, T, P> operator<<(vec<3, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator<<(tvec<3, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator<<(T scalar, tvec<3, T, P> const & v); GLM_FUNC_DECL vec<3, T, P> operator<<(T scalar, vec<3, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator<<(tvec<1, T, P> const & v1, tvec<3, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator<<(tvec<3, T, P> const & v1, tvec<3, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator>>(tvec<3, T, P> const & v, T scalar); GLM_FUNC_DECL vec<3, T, P> operator>>(vec<3, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator>>(tvec<3, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator>>(T scalar, tvec<3, T, P> const & v); GLM_FUNC_DECL vec<3, T, P> operator>>(T scalar, vec<3, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator>>(tvec<1, T, P> const & v1, tvec<3, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator>>(tvec<3, T, P> const & v1, tvec<3, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<3, T, P> operator~(tvec<3, T, P> const & v); GLM_FUNC_DECL vec<3, T, P> operator~(vec<3, T, P> const & v);
// -- Boolean operators -- // -- Boolean operators --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL bool operator==(tvec<3, T, P> const & v1, tvec<3, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL bool operator!=(tvec<3, T, P> const & v1, tvec<3, T, P> const & v2); GLM_FUNC_DECL bool operator!=(vec<3, T, P> const & v1, vec<3, T, P> const & v2);
template <precision P> template <precision P>
GLM_FUNC_DECL tvec<3, bool, P> operator&&(tvec<3, bool, P> const & v1, tvec<3, bool, P> const & v2); GLM_FUNC_DECL vec<3, bool, P> operator&&(vec<3, bool, P> const & v1, vec<3, bool, P> const & v2);
template <precision P> template <precision P>
GLM_FUNC_DECL tvec<3, bool, P> operator||(tvec<3, bool, P> const & v1, tvec<3, bool, P> const & v2); GLM_FUNC_DECL vec<3, bool, P> operator||(vec<3, bool, P> const & v1, vec<3, bool, P> const & v2);
}//namespace glm }//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE #ifndef GLM_EXTERNAL_TEMPLATE

330
glm/detail/type_vec3.inl
View File

File diff suppressed because it is too large Load Diff

258
glm/detail/type_vec4.hpp
View File

@ -16,13 +16,13 @@
namespace glm namespace glm
{ {
template <typename T, precision P> template <typename T, precision P>
struct tvec<4, T, P> struct vec<4, T, P>
{ {
// -- Implementation detail -- // -- Implementation detail --
typedef T value_type; typedef T value_type;
typedef tvec<4, T, P> type; typedef vec<4, T, P> type;
typedef tvec<4, bool, P> bool_type; typedef vec<4, bool, P> bool_type;
// -- Data -- // -- Data --
@ -86,364 +86,364 @@ namespace glm
// -- Implicit basic constructors -- // -- Implicit basic constructors --
GLM_FUNC_DECL GLM_CONSTEXPR_SIMD tvec() GLM_DEFAULT_CTOR; GLM_FUNC_DECL GLM_CONSTEXPR_SIMD vec() GLM_DEFAULT_CTOR;
GLM_FUNC_DECL GLM_CONSTEXPR_SIMD tvec(tvec<4, T, P> const& v) GLM_DEFAULT; GLM_FUNC_DECL GLM_CONSTEXPR_SIMD vec(vec<4, T, P> const& v) GLM_DEFAULT;
template <precision Q> template <precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR_SIMD tvec(tvec<4, T, Q> const& v); GLM_FUNC_DECL GLM_CONSTEXPR_SIMD vec(vec<4, T, Q> const& v);
// -- Explicit basic constructors -- // -- Explicit basic constructors --
GLM_FUNC_DECL GLM_CONSTEXPR_SIMD explicit tvec(ctor); GLM_FUNC_DECL GLM_CONSTEXPR_SIMD explicit vec(ctor);
GLM_FUNC_DECL GLM_CONSTEXPR_SIMD explicit tvec(T scalar); GLM_FUNC_DECL GLM_CONSTEXPR_SIMD explicit vec(T scalar);
GLM_FUNC_DECL GLM_CONSTEXPR_SIMD tvec(T a, T b, T c, T d); GLM_FUNC_DECL GLM_CONSTEXPR_SIMD vec(T a, T b, T c, T d);
// -- Conversion scalar constructors -- // -- Conversion scalar constructors --
/// Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) /// Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C, typename D> template <typename A, typename B, typename C, typename D>
GLM_FUNC_DECL GLM_CONSTEXPR_SIMD tvec(A a, B b, C c, D d); GLM_FUNC_DECL GLM_CONSTEXPR_SIMD vec(A a, B b, C c, D d);
template <typename A, typename B, typename C, typename D> template <typename A, typename B, typename C, typename D>
GLM_FUNC_DECL GLM_CONSTEXPR_CTOR tvec(tvec<1, A, P> const& a, tvec<1, B, P> const& b, tvec<1, C, P> const& c, tvec<1, D, P> const& d); GLM_FUNC_DECL GLM_CONSTEXPR_CTOR vec(vec<1, A, P> const& a, vec<1, B, P> const& b, vec<1, C, P> const& c, vec<1, D, P> const& d);
// -- Conversion vector constructors -- // -- Conversion vector constructors --
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR tvec(tvec<2, A, Q> const & a, B b, C c); GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, Q> const & a, B b, C c);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR tvec(tvec<2, A, Q> const & a, tvec<1, B, Q> const & b, tvec<1, C, Q> const & c); GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, Q> const & a, vec<1, B, Q> const & b, vec<1, C, Q> const & c);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR tvec(A a, tvec<2, B, Q> const & b, C c); GLM_FUNC_DECL GLM_CONSTEXPR vec(A a, vec<2, B, Q> const & b, C c);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR tvec(tvec<1, A, Q> const & a, tvec<2, B, Q> const & b, tvec<1, C, Q> const & c); GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, Q> const & a, vec<2, B, Q> const & b, vec<1, C, Q> const & c);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR tvec(A a, B b, tvec<2, C, Q> const & c); GLM_FUNC_DECL GLM_CONSTEXPR vec(A a, B b, vec<2, C, Q> const & c);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR tvec(tvec<1, A, Q> const & a, tvec<1, B, Q> const & b, tvec<2, C, Q> const & c); GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, Q> const & a, vec<1, B, Q> const & b, vec<2, C, Q> const & c);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR tvec(tvec<3, A, Q> const & a, B b); GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<3, A, Q> const & a, B b);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR tvec(tvec<3, A, Q> const & a, tvec<1, B, Q> const & b); GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<3, A, Q> const & a, vec<1, B, Q> const & b);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR tvec(A a, tvec<3, B, Q> const & b); GLM_FUNC_DECL GLM_CONSTEXPR vec(A a, vec<3, B, Q> const & b);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR tvec(tvec<1, A, Q> const & a, tvec<3, B, Q> const & b); GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<1, A, Q> const & a, vec<3, B, Q> const & b);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR tvec(tvec<2, A, Q> const & a, tvec<2, B, Q> const & b); GLM_FUNC_DECL GLM_CONSTEXPR vec(vec<2, A, Q> const & a, vec<2, B, Q> const & b);
/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification) /// 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, precision Q>
GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec(tvec<4, U, Q> const& v); GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT vec(vec<4, U, Q> const& v);
// -- Swizzle constructors -- // -- Swizzle constructors --
# if GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED) # if GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)
template <int E0, int E1, int E2, int E3> template <int E0, int E1, int E2, int E3>
GLM_FUNC_DECL tvec(detail::_swizzle<4, T, P, E0, E1, E2, E3> const & that) GLM_FUNC_DECL vec(detail::_swizzle<4, T, P, E0, E1, E2, E3> const & that)
{ {
*this = that(); *this = that();
} }
template <int E0, int E1, int F0, int F1> template <int E0, int E1, int F0, int F1>
GLM_FUNC_DECL tvec(detail::_swizzle<2, T, P, E0, E1, -1, -2> const & v, detail::_swizzle<2, T, P, F0, F1, -1, -2> const & u) GLM_FUNC_DECL vec(detail::_swizzle<2, T, P, E0, E1, -1, -2> const & v, detail::_swizzle<2, T, P, F0, F1, -1, -2> const & u)
{ {
*this = tvec<4, T, P>(v(), u()); *this = vec<4, T, P>(v(), u());
} }
template <int E0, int E1> template <int E0, int E1>
GLM_FUNC_DECL tvec(T const & x, T const & y, detail::_swizzle<2, T, P, E0, E1, -1, -2> const & v) GLM_FUNC_DECL vec(T const & x, T const & y, detail::_swizzle<2, T, P, E0, E1, -1, -2> const & v)
{ {
*this = tvec<4, T, P>(x, y, v()); *this = vec<4, T, P>(x, y, v());
} }
template <int E0, int E1> template <int E0, int E1>
GLM_FUNC_DECL tvec(T const & x, detail::_swizzle<2, T, P, E0, E1, -1, -2> const & v, T const & w) GLM_FUNC_DECL vec(T const & x, detail::_swizzle<2, T, P, E0, E1, -1, -2> const & v, T const & w)
{ {
*this = tvec<4, T, P>(x, v(), w); *this = vec<4, T, P>(x, v(), w);
} }
template <int E0, int E1> template <int E0, int E1>
GLM_FUNC_DECL tvec(detail::_swizzle<2, T, P, E0, E1, -1, -2> const & v, T const & z, T const & w) GLM_FUNC_DECL vec(detail::_swizzle<2, T, P, E0, E1, -1, -2> const & v, T const & z, T const & w)
{ {
*this = tvec<4, T, P>(v(), z, w); *this = vec<4, T, P>(v(), z, w);
} }
template <int E0, int E1, int E2> template <int E0, int E1, int E2>
GLM_FUNC_DECL tvec(detail::_swizzle<3, T, P, E0, E1, E2, -1> const & v, T const & w) GLM_FUNC_DECL vec(detail::_swizzle<3, T, P, E0, E1, E2, -1> const & v, T const & w)
{ {
*this = tvec<4, T, P>(v(), w); *this = vec<4, T, P>(v(), w);
} }
template <int E0, int E1, int E2> template <int E0, int E1, int E2>
GLM_FUNC_DECL tvec(T const & x, detail::_swizzle<3, T, P, E0, E1, E2, -1> const & v) GLM_FUNC_DECL vec(T const & x, detail::_swizzle<3, T, P, E0, E1, E2, -1> const & v)
{ {
*this = tvec<4, T, P>(x, v()); *this = vec<4, T, P>(x, v());
} }
# endif// GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED) # endif// GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)
// -- Unary arithmetic operators -- // -- Unary arithmetic operators --
GLM_FUNC_DECL tvec<4, T, P> & operator=(tvec<4, T, P> const & v) GLM_DEFAULT; GLM_FUNC_DECL vec<4, T, P> & operator=(vec<4, T, P> const & v) GLM_DEFAULT;
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator=(tvec<4, U, P> const & v); GLM_FUNC_DECL vec<4, T, P> & operator=(vec<4, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator+=(U scalar); GLM_FUNC_DECL vec<4, T, P> & operator+=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator+=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec<4, T, P> & operator+=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator+=(tvec<4, U, P> const & v); GLM_FUNC_DECL vec<4, T, P> & operator+=(vec<4, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator-=(U scalar); GLM_FUNC_DECL vec<4, T, P> & operator-=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator-=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec<4, T, P> & operator-=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator-=(tvec<4, U, P> const & v); GLM_FUNC_DECL vec<4, T, P> & operator-=(vec<4, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator*=(U scalar); GLM_FUNC_DECL vec<4, T, P> & operator*=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator*=(tvec<1, U, P> const& v); GLM_FUNC_DECL vec<4, T, P> & operator*=(vec<1, U, P> const& v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator*=(tvec<4, U, P> const& v); GLM_FUNC_DECL vec<4, T, P> & operator*=(vec<4, U, P> const& v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator/=(U scalar); GLM_FUNC_DECL vec<4, T, P> & operator/=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator/=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec<4, T, P> & operator/=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator/=(tvec<4, U, P> const & v); GLM_FUNC_DECL vec<4, T, P> & operator/=(vec<4, U, P> const & v);
// -- Increment and decrement operators -- // -- Increment and decrement operators --
GLM_FUNC_DECL tvec<4, T, P> & operator++(); GLM_FUNC_DECL vec<4, T, P> & operator++();
GLM_FUNC_DECL tvec<4, T, P> & operator--(); GLM_FUNC_DECL vec<4, T, P> & operator--();
GLM_FUNC_DECL tvec<4, T, P> operator++(int); GLM_FUNC_DECL vec<4, T, P> operator++(int);
GLM_FUNC_DECL tvec<4, T, P> operator--(int); GLM_FUNC_DECL vec<4, T, P> operator--(int);
// -- Unary bit operators -- // -- Unary bit operators --
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator%=(U scalar); GLM_FUNC_DECL vec<4, T, P> & operator%=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator%=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec<4, T, P> & operator%=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator%=(tvec<4, U, P> const & v); GLM_FUNC_DECL vec<4, T, P> & operator%=(vec<4, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator&=(U scalar); GLM_FUNC_DECL vec<4, T, P> & operator&=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator&=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec<4, T, P> & operator&=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator&=(tvec<4, U, P> const & v); GLM_FUNC_DECL vec<4, T, P> & operator&=(vec<4, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator|=(U scalar); GLM_FUNC_DECL vec<4, T, P> & operator|=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator|=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec<4, T, P> & operator|=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator|=(tvec<4, U, P> const & v); GLM_FUNC_DECL vec<4, T, P> & operator|=(vec<4, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator^=(U scalar); GLM_FUNC_DECL vec<4, T, P> & operator^=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator^=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec<4, T, P> & operator^=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator^=(tvec<4, U, P> const & v); GLM_FUNC_DECL vec<4, T, P> & operator^=(vec<4, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator<<=(U scalar); GLM_FUNC_DECL vec<4, T, P> & operator<<=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator<<=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec<4, T, P> & operator<<=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator<<=(tvec<4, U, P> const & v); GLM_FUNC_DECL vec<4, T, P> & operator<<=(vec<4, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator>>=(U scalar); GLM_FUNC_DECL vec<4, T, P> & operator>>=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator>>=(tvec<1, U, P> const & v); GLM_FUNC_DECL vec<4, T, P> & operator>>=(vec<1, U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec<4, T, P> & operator>>=(tvec<4, U, P> const & v); GLM_FUNC_DECL vec<4, T, P> & operator>>=(vec<4, U, P> const & v);
}; };
// -- Unary operators -- // -- Unary operators --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator+(tvec<4, T, P> const & v); GLM_FUNC_DECL vec<4, T, P> operator+(vec<4, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator-(tvec<4, T, P> const & v); GLM_FUNC_DECL vec<4, T, P> operator-(vec<4, T, P> const & v);
// -- Binary operators -- // -- Binary operators --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator+(tvec<4, T, P> const & v, T scalar); GLM_FUNC_DECL vec<4, T, P> operator+(vec<4, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator+(tvec<4, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator+(T scalar, tvec<4, T, P> const & v); GLM_FUNC_DECL vec<4, T, P> operator+(T scalar, vec<4, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator+(tvec<1, T, P> const & v1, tvec<4, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator+(tvec<4, T, P> const & v1, tvec<4, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator-(tvec<4, T, P> const & v, T scalar); GLM_FUNC_DECL vec<4, T, P> operator-(vec<4, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator-(tvec<4, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator-(T scalar, tvec<4, T, P> const & v); GLM_FUNC_DECL vec<4, T, P> operator-(T scalar, vec<4, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator-(tvec<1, T, P> const & v1, tvec<4, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator-(tvec<4, T, P> const & v1, tvec<4, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator*(tvec<4, T, P> const & v, T scalar); GLM_FUNC_DECL vec<4, T, P> operator*(vec<4, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator*(tvec<4, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator*(T scalar, tvec<4, T, P> const & v); GLM_FUNC_DECL vec<4, T, P> operator*(T scalar, vec<4, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator*(tvec<1, T, P> const & v1, tvec<4, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator*(tvec<4, T, P> const & v1, tvec<4, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator/(tvec<4, T, P> const & v, T scalar); GLM_FUNC_DECL vec<4, T, P> operator/(vec<4, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator/(tvec<4, T, P> const & v1, tvec<1, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator/(T scalar, tvec<4, T, P> const & v); GLM_FUNC_DECL vec<4, T, P> operator/(T scalar, vec<4, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator/(tvec<1, T, P> const & v1, tvec<4, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator/(tvec<4, T, P> const & v1, tvec<4, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator%(tvec<4, T, P> const & v, T scalar); GLM_FUNC_DECL vec<4, T, P> operator%(vec<4, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator%(tvec<4, T, P> const & v, tvec<1, T, P> const & scalar); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator%(T scalar, tvec<4, T, P> const & v); GLM_FUNC_DECL vec<4, T, P> operator%(T scalar, vec<4, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator%(tvec<1, T, P> const & scalar, tvec<4, T, P> const & v); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator%(tvec<4, T, P> const & v1, tvec<4, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator&(tvec<4, T, P> const & v, T scalar); GLM_FUNC_DECL vec<4, T, P> operator&(vec<4, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator&(tvec<4, T, P> const & v, tvec<1, T, P> const & scalar); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator&(T scalar, tvec<4, T, P> const & v); GLM_FUNC_DECL vec<4, T, P> operator&(T scalar, vec<4, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator&(tvec<1, T, P> const & scalar, tvec<4, T, P> const & v); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator&(tvec<4, T, P> const & v1, tvec<4, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator|(tvec<4, T, P> const & v, T scalar); GLM_FUNC_DECL vec<4, T, P> operator|(vec<4, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator|(tvec<4, T, P> const & v, tvec<1, T, P> const & scalar); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator|(T scalar, tvec<4, T, P> const & v); GLM_FUNC_DECL vec<4, T, P> operator|(T scalar, vec<4, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator|(tvec<1, T, P> const & scalar, tvec<4, T, P> const & v); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator|(tvec<4, T, P> const & v1, tvec<4, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator^(tvec<4, T, P> const & v, T scalar); GLM_FUNC_DECL vec<4, T, P> operator^(vec<4, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator^(tvec<4, T, P> const & v, tvec<1, T, P> const & scalar); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator^(T scalar, tvec<4, T, P> const & v); GLM_FUNC_DECL vec<4, T, P> operator^(T scalar, vec<4, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator^(tvec<1, T, P> const & scalar, tvec<4, T, P> const & v); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator^(tvec<4, T, P> const & v1, tvec<4, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator<<(tvec<4, T, P> const & v, T scalar); GLM_FUNC_DECL vec<4, T, P> operator<<(vec<4, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator<<(tvec<4, T, P> const & v, tvec<1, T, P> const & scalar); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator<<(T scalar, tvec<4, T, P> const & v); GLM_FUNC_DECL vec<4, T, P> operator<<(T scalar, vec<4, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator<<(tvec<1, T, P> const & scalar, tvec<4, T, P> const & v); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator<<(tvec<4, T, P> const & v1, tvec<4, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator>>(tvec<4, T, P> const & v, T scalar); GLM_FUNC_DECL vec<4, T, P> operator>>(vec<4, T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator>>(tvec<4, T, P> const & v, tvec<1, T, P> const & scalar); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator>>(T scalar, tvec<4, T, P> const & v); GLM_FUNC_DECL vec<4, T, P> operator>>(T scalar, vec<4, T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator>>(tvec<1, T, P> const & scalar, tvec<4, T, P> const & v); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator>>(tvec<4, T, P> const & v1, tvec<4, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL tvec<4, T, P> operator~(tvec<4, T, P> const & v); GLM_FUNC_DECL vec<4, T, P> operator~(vec<4, T, P> const & v);
// -- Boolean operators -- // -- Boolean operators --
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL bool operator==(tvec<4, T, P> const & v1, tvec<4, T, P> const & v2); 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, precision P>
GLM_FUNC_DECL bool operator!=(tvec<4, T, P> const & v1, tvec<4, T, P> const & v2); GLM_FUNC_DECL bool operator!=(vec<4, T, P> const & v1, vec<4, T, P> const & v2);
template <precision P> template <precision P>
GLM_FUNC_DECL tvec<4, bool, P> operator&&(tvec<4, bool, P> const & v1, tvec<4, bool, P> const & v2); GLM_FUNC_DECL vec<4, bool, P> operator&&(vec<4, bool, P> const & v1, vec<4, bool, P> const & v2);
template <precision P> template <precision P>
GLM_FUNC_DECL tvec<4, bool, P> operator||(tvec<4, bool, P> const & v1, tvec<4, bool, P> const & v2); GLM_FUNC_DECL vec<4, bool, P> operator||(vec<4, bool, P> const & v1, vec<4, bool, P> const & v2);
}//namespace glm }//namespace glm
#ifndef GLM_EXTERNAL_TEMPLATE #ifndef GLM_EXTERNAL_TEMPLATE

448
glm/detail/type_vec4.inl
View File

File diff suppressed because it is too large Load Diff

48
glm/detail/type_vec4_simd.inl
View File

@ -341,21 +341,21 @@ namespace detail
# if !GLM_HAS_DEFAULTED_FUNCTIONS # if !GLM_HAS_DEFAULTED_FUNCTIONS
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_lowp>::tvec() GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_lowp>::vec()
# ifndef GLM_FORCE_NO_CTOR_INIT # ifndef GLM_FORCE_NO_CTOR_INIT
: data(_mm_setzero_ps()) : data(_mm_setzero_ps())
# endif # endif
{} {}
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_mediump>::tvec() GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_mediump>::vec()
# ifndef GLM_FORCE_NO_CTOR_INIT # ifndef GLM_FORCE_NO_CTOR_INIT
: data(_mm_setzero_ps()) : data(_mm_setzero_ps())
# endif # endif
{} {}
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_highp>::tvec() GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_highp>::vec()
# ifndef GLM_FORCE_NO_CTOR_INIT # ifndef GLM_FORCE_NO_CTOR_INIT
: data(_mm_setzero_ps()) : data(_mm_setzero_ps())
# endif # endif
@ -363,117 +363,117 @@ namespace detail
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS # endif//!GLM_HAS_DEFAULTED_FUNCTIONS
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_lowp>::tvec(float s) : GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_lowp>::vec(float s) :
data(_mm_set1_ps(s)) data(_mm_set1_ps(s))
{} {}
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_mediump>::tvec(float s) : GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_mediump>::vec(float s) :
data(_mm_set1_ps(s)) data(_mm_set1_ps(s))
{} {}
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_highp>::tvec(float s) : GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_highp>::vec(float s) :
data(_mm_set1_ps(s)) data(_mm_set1_ps(s))
{} {}
# if GLM_ARCH & GLM_ARCH_AVX_BIT # if GLM_ARCH & GLM_ARCH_AVX_BIT
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<double, aligned_lowp>::tvec(double s) : GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<double, aligned_lowp>::vec(double s) :
data(_mm256_set1_pd(s)) data(_mm256_set1_pd(s))
{} {}
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<double, aligned_mediump>::tvec(double s) : GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<double, aligned_mediump>::vec(double s) :
data(_mm256_set1_pd(s)) data(_mm256_set1_pd(s))
{} {}
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<double, aligned_highp>::tvec(double s) : GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<double, aligned_highp>::vec(double s) :
data(_mm256_set1_pd(s)) data(_mm256_set1_pd(s))
{} {}
# endif # endif
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int32, aligned_lowp>::tvec(int32 s) : GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int32, aligned_lowp>::vec(int32 s) :
data(_mm_set1_epi32(s)) data(_mm_set1_epi32(s))
{} {}
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int32, aligned_mediump>::tvec(int32 s) : GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int32, aligned_mediump>::vec(int32 s) :
data(_mm_set1_epi32(s)) data(_mm_set1_epi32(s))
{} {}
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int32, aligned_highp>::tvec(int32 s) : GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int32, aligned_highp>::vec(int32 s) :
data(_mm_set1_epi32(s)) data(_mm_set1_epi32(s))
{} {}
# if GLM_ARCH & GLM_ARCH_AVX2_BIT # if GLM_ARCH & GLM_ARCH_AVX2_BIT
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int64, aligned_lowp>::tvec(int64 s) : GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int64, aligned_lowp>::vec(int64 s) :
data(_mm256_set1_epi64x(s)) data(_mm256_set1_epi64x(s))
{} {}
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int64, aligned_mediump>::tvec(int64 s) : GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int64, aligned_mediump>::vec(int64 s) :
data(_mm256_set1_epi64x(s)) data(_mm256_set1_epi64x(s))
{} {}
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int64, aligned_highp>::tvec(int64 s) : GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int64, aligned_highp>::vec(int64 s) :
data(_mm256_set1_epi64x(s)) data(_mm256_set1_epi64x(s))
{} {}
# endif # endif
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_lowp>::tvec(float a, float b, float c, float d) : GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_lowp>::vec(float a, float b, float c, float d) :
data(_mm_set_ps(d, c, b, a)) data(_mm_set_ps(d, c, b, a))
{} {}
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_mediump>::tvec(float a, float b, float c, float d) : GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_mediump>::vec(float a, float b, float c, float d) :
data(_mm_set_ps(d, c, b, a)) data(_mm_set_ps(d, c, b, a))
{} {}
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_highp>::tvec(float a, float b, float c, float d) : GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_highp>::vec(float a, float b, float c, float d) :
data(_mm_set_ps(d, c, b, a)) data(_mm_set_ps(d, c, b, a))
{} {}
template <> template <>
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int32, aligned_lowp>::tvec(int32 a, int32 b, int32 c, int32 d) : GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int32, aligned_lowp>::vec(int32 a, int32 b, int32 c, int32 d) :
data(_mm_set_epi32(d, c, b, a)) data(_mm_set_epi32(d, c, b, a))
{} {}
template <> template <>
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int32, aligned_mediump>::tvec(int32 a, int32 b, int32 c, int32 d) : GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int32, aligned_mediump>::vec(int32 a, int32 b, int32 c, int32 d) :
data(_mm_set_epi32(d, c, b, a)) data(_mm_set_epi32(d, c, b, a))
{} {}
template <> template <>
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int32, aligned_highp>::tvec(int32 a, int32 b, int32 c, int32 d) : GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<int32, aligned_highp>::vec(int32 a, int32 b, int32 c, int32 d) :
data(_mm_set_epi32(d, c, b, a)) data(_mm_set_epi32(d, c, b, a))
{} {}
template <> template <>
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_lowp>::tvec(int32 a, int32 b, int32 c, int32 d) : GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_lowp>::vec(int32 a, int32 b, int32 c, int32 d) :
data(_mm_castsi128_ps(_mm_set_epi32(d, c, b, a))) data(_mm_castsi128_ps(_mm_set_epi32(d, c, b, a)))
{} {}
template <> template <>
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_mediump>::tvec(int32 a, int32 b, int32 c, int32 d) : GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_mediump>::vec(int32 a, int32 b, int32 c, int32 d) :
data(_mm_castsi128_ps(_mm_set_epi32(d, c, b, a))) data(_mm_castsi128_ps(_mm_set_epi32(d, c, b, a)))
{} {}
template <> template <>
template <> template <>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_highp>::tvec(int32 a, int32 b, int32 c, int32 d) : GLM_FUNC_QUALIFIER GLM_CONSTEXPR_SIMD tvec4<float, aligned_highp>::vec(int32 a, int32 b, int32 c, int32 d) :
data(_mm_castsi128_ps(_mm_set_epi32(d, c, b, a))) data(_mm_castsi128_ps(_mm_set_epi32(d, c, b, a)))
{} {}
}//namespace glm }//namespace glm

8
glm/gtc/color_space.inl
View File

@ -19,11 +19,11 @@ namespace detail
}; };
template <typename T, precision P> template <typename T, precision P>
struct compute_rgbToSrgb<4, T, P, tvec> struct compute_rgbToSrgb<4, T, P, vec>
{ {
GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const& ColorRGB, T GammaCorrection) GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const& ColorRGB, T GammaCorrection)
{ {
return tvec4<T, P>(compute_rgbToSrgb<3, T, P, tvec>::call(tvec3<T, P>(ColorRGB), GammaCorrection), ColorRGB.a); return tvec4<T, P>(compute_rgbToSrgb<3, T, P, vec>::call(tvec3<T, P>(ColorRGB), GammaCorrection), ColorRGB.a);
} }
}; };
@ -40,11 +40,11 @@ namespace detail
}; };
template <typename T, precision P> template <typename T, precision P>
struct compute_srgbToRgb<4, T, P, tvec> struct compute_srgbToRgb<4, T, P, vec>
{ {
GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const& ColorSRGB, T Gamma) GLM_FUNC_QUALIFIER static tvec4<T, P> call(tvec4<T, P> const& ColorSRGB, T Gamma)
{ {
return tvec4<T, P>(compute_srgbToRgb<3, T, P, tvec>::call(tvec3<T, P>(ColorSRGB), Gamma), ColorSRGB.a); return tvec4<T, P>(compute_srgbToRgb<3, T, P, vec>::call(tvec3<T, P>(ColorSRGB), Gamma), ColorSRGB.a);
} }
}; };
}//namespace detail }//namespace detail

2
glm/gtc/integer.inl
View File

@ -17,7 +17,7 @@ namespace detail
# if GLM_HAS_BITSCAN_WINDOWS # if GLM_HAS_BITSCAN_WINDOWS
template <precision P, bool Aligned> template <precision P, bool Aligned>
struct compute_log2<4, int, P, tvec, false, Aligned> struct compute_log2<4, int, P, vec, false, Aligned>
{ {
GLM_FUNC_QUALIFIER static tvec4<int, P> call(tvec4<int, P> const & vec) GLM_FUNC_QUALIFIER static tvec4<int, P> call(tvec4<int, P> const & vec)
{ {

48
glm/gtc/packing.inl
View File

@ -275,9 +275,9 @@ namespace detail
{}; {};
template <precision P> template <precision P>
struct compute_half<1, P, tvec> struct compute_half<1, P, vec>
{ {
GLM_FUNC_QUALIFIER static tvec<1, uint16, P> pack(tvec<1, float, P> const & v) GLM_FUNC_QUALIFIER static vec<1, uint16, P> pack(vec<1, float, P> const & v)
{ {
int16 const Unpack(detail::toFloat16(v.x)); int16 const Unpack(detail::toFloat16(v.x));
u16vec1 Packed(uninitialize); u16vec1 Packed(uninitialize);
@ -285,68 +285,68 @@ namespace detail
return Packed; return Packed;
} }
GLM_FUNC_QUALIFIER static tvec<1, float, P> unpack(tvec<1, uint16, P> const & v) GLM_FUNC_QUALIFIER static vec<1, float, P> unpack(vec<1, uint16, P> const & v)
{ {
i16vec1 Unpack(uninitialize); i16vec1 Unpack(uninitialize);
memcpy(&Unpack, &v, sizeof(Unpack)); memcpy(&Unpack, &v, sizeof(Unpack));
return tvec<1, float, P>(detail::toFloat32(v.x)); return vec<1, float, P>(detail::toFloat32(v.x));
} }
}; };
template <precision P> template <precision P>
struct compute_half<2, P, tvec> struct compute_half<2, P, vec>
{ {
GLM_FUNC_QUALIFIER static tvec<2, uint16, P> pack(tvec<2, float, P> const & v) GLM_FUNC_QUALIFIER static vec<2, uint16, P> pack(vec<2, float, P> const & v)
{ {
tvec<2, int16, P> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y)); vec<2, int16, P> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y));
u16vec2 Packed(uninitialize); u16vec2 Packed(uninitialize);
memcpy(&Packed, &Unpack, sizeof(Packed)); memcpy(&Packed, &Unpack, sizeof(Packed));
return Packed; return Packed;
} }
GLM_FUNC_QUALIFIER static tvec<2, float, P> unpack(tvec<2, uint16, P> const & v) GLM_FUNC_QUALIFIER static vec<2, float, P> unpack(vec<2, uint16, P> const & v)
{ {
i16vec2 Unpack(uninitialize); i16vec2 Unpack(uninitialize);
memcpy(&Unpack, &v, sizeof(Unpack)); memcpy(&Unpack, &v, sizeof(Unpack));
return tvec<2, float, P>(detail::toFloat32(v.x), detail::toFloat32(v.y)); return vec<2, float, P>(detail::toFloat32(v.x), detail::toFloat32(v.y));
} }
}; };
template <precision P> template <precision P>
struct compute_half<3, P, tvec> struct compute_half<3, P, vec>
{ {
GLM_FUNC_QUALIFIER static tvec<3, uint16, P> pack(tvec<3, float, P> const & v) GLM_FUNC_QUALIFIER static vec<3, uint16, P> pack(vec<3, float, P> const & v)
{ {
tvec<3, int16, P> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y), detail::toFloat16(v.z)); vec<3, int16, P> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y), detail::toFloat16(v.z));
u16vec3 Packed(uninitialize); u16vec3 Packed(uninitialize);
memcpy(&Packed, &Unpack, sizeof(Packed)); memcpy(&Packed, &Unpack, sizeof(Packed));
return Packed; return Packed;
} }
GLM_FUNC_QUALIFIER static tvec<3, float, P> unpack(tvec<3, uint16, P> const & v) GLM_FUNC_QUALIFIER static vec<3, float, P> unpack(vec<3, uint16, P> const & v)
{ {
i16vec3 Unpack(uninitialize); i16vec3 Unpack(uninitialize);
memcpy(&Unpack, &v, sizeof(Unpack)); memcpy(&Unpack, &v, sizeof(Unpack));
return tvec<3, float, P>(detail::toFloat32(v.x), detail::toFloat32(v.y), detail::toFloat32(v.z)); return vec<3, float, P>(detail::toFloat32(v.x), detail::toFloat32(v.y), detail::toFloat32(v.z));
} }
}; };
template <precision P> template <precision P>
struct compute_half<4, P, tvec> struct compute_half<4, P, vec>
{ {
GLM_FUNC_QUALIFIER static tvec<4, uint16, P> pack(tvec<4, float, P> const & v) GLM_FUNC_QUALIFIER static vec<4, uint16, P> pack(vec<4, float, P> const & v)
{ {
tvec<4, int16, P> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y), detail::toFloat16(v.z), detail::toFloat16(v.w)); vec<4, int16, P> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y), detail::toFloat16(v.z), detail::toFloat16(v.w));
u16vec4 Packed(uninitialize); u16vec4 Packed(uninitialize);
memcpy(&Packed, &Unpack, sizeof(Packed)); memcpy(&Packed, &Unpack, sizeof(Packed));
return Packed; return Packed;
} }
GLM_FUNC_QUALIFIER static tvec<4, float, P> unpack(tvec<4, uint16, P> const & v) GLM_FUNC_QUALIFIER static vec<4, float, P> unpack(vec<4, uint16, P> const & v)
{ {
i16vec4 Unpack(uninitialize); i16vec4 Unpack(uninitialize);
memcpy(&Unpack, &v, sizeof(Unpack)); memcpy(&Unpack, &v, sizeof(Unpack));
return tvec<4, float, P>(detail::toFloat32(v.x), detail::toFloat32(v.y), detail::toFloat32(v.z), detail::toFloat32(v.w)); return vec<4, float, P>(detail::toFloat32(v.x), detail::toFloat32(v.y), detail::toFloat32(v.z), detail::toFloat32(v.w));
} }
}; };
}//namespace detail }//namespace detail
@ -641,18 +641,18 @@ namespace detail
// Based on Brian Karis http://graphicrants.blogspot.fr/2009/04/rgbm-color-encoding.html // Based on Brian Karis http://graphicrants.blogspot.fr/2009/04/rgbm-color-encoding.html
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<4, T, P> packRGBM(tvec<3, T, P> const & rgb) GLM_FUNC_QUALIFIER vec<4, T, P> packRGBM(vec<3, T, P> const & rgb)
{ {
tvec<3, T, P> const Color(rgb * static_cast<T>(1.0 / 6.0)); vec<3, T, P> const Color(rgb * static_cast<T>(1.0 / 6.0));
T Alpha = clamp(max(max(Color.x, Color.y), max(Color.z, static_cast<T>(1e-6))), static_cast<T>(0), static_cast<T>(1)); T Alpha = clamp(max(max(Color.x, Color.y), max(Color.z, static_cast<T>(1e-6))), static_cast<T>(0), static_cast<T>(1));
Alpha = ceil(Alpha * static_cast<T>(255.0)) / static_cast<T>(255.0); Alpha = ceil(Alpha * static_cast<T>(255.0)) / static_cast<T>(255.0);
return tvec<4, T, P>(Color / Alpha, Alpha); return vec<4, T, P>(Color / Alpha, Alpha);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec<3, T, P> unpackRGBM(tvec<4, T, P> const & rgbm) GLM_FUNC_QUALIFIER vec<3, T, P> unpackRGBM(vec<4, T, P> const & rgbm)
{ {
return tvec<3, T, P>(rgbm.x, rgbm.y, rgbm.z) * rgbm.w * static_cast<T>(6); return vec<3, T, P>(rgbm.x, rgbm.y, rgbm.z) * rgbm.w * static_cast<T>(6);
} }
template <int D, precision P, template <int, typename, precision> class vecType> template <int D, precision P, template <int, typename, precision> class vecType>

2
glm/gtc/quaternion.inl
View File

@ -154,7 +154,7 @@ namespace detail
GLM_FUNC_QUALIFIER tquat<T, P>::tquat(tvec3<T, P> const & u, tvec3<T, P> const & v) GLM_FUNC_QUALIFIER tquat<T, P>::tquat(tvec3<T, P> const & u, tvec3<T, P> const & v)
{ {
tvec3<T, P> const LocalW(cross(u, v)); tvec3<T, P> const LocalW(cross(u, v));
T Dot = detail::compute_dot<tvec<3, T, P>, T, detail::is_aligned<P>::value>::call(u, v); T Dot = detail::compute_dot<vec<3, T, P>, T, detail::is_aligned<P>::value>::call(u, v);
tquat<T, P> q(T(1) + Dot, LocalW.x, LocalW.y, LocalW.z); tquat<T, P> q(T(1) + Dot, LocalW.x, LocalW.y, LocalW.z);
*this = normalize(q); *this = normalize(q);

10
glm/gtc/random.inl
View File

@ -17,7 +17,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_rand<1, uint8, P, tvec> struct compute_rand<1, uint8, P, vec>
{ {
GLM_FUNC_QUALIFIER static tvec1<uint8, P> call() GLM_FUNC_QUALIFIER static tvec1<uint8, P> call()
{ {
@ -27,7 +27,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_rand<2, uint8, P, tvec> struct compute_rand<2, uint8, P, vec>
{ {
GLM_FUNC_QUALIFIER static tvec2<uint8, P> call() GLM_FUNC_QUALIFIER static tvec2<uint8, P> call()
{ {
@ -38,7 +38,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_rand<3, uint8, P, tvec> struct compute_rand<3, uint8, P, vec>
{ {
GLM_FUNC_QUALIFIER static tvec3<uint8, P> call() GLM_FUNC_QUALIFIER static tvec3<uint8, P> call()
{ {
@ -50,7 +50,7 @@ namespace detail
}; };
template <precision P> template <precision P>
struct compute_rand<4, uint8, P, tvec> struct compute_rand<4, uint8, P, vec>
{ {
GLM_FUNC_QUALIFIER static tvec4<uint8, P> call() GLM_FUNC_QUALIFIER static tvec4<uint8, P> call()
{ {
@ -258,7 +258,7 @@ namespace detail
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER genType linearRand(genType Min, genType Max) GLM_FUNC_QUALIFIER genType linearRand(genType Min, genType Max)
{ {
return detail::compute_linearRand<1, genType, highp, tvec>::call( return detail::compute_linearRand<1, genType, highp, vec>::call(
tvec1<genType, highp>(Min), tvec1<genType, highp>(Min),
tvec1<genType, highp>(Max)).x; tvec1<genType, highp>(Max)).x;
} }

2
glm/gtc/round.inl
View File

@ -232,7 +232,7 @@ namespace detail
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER genType ceilPowerOfTwo(genType value) GLM_FUNC_QUALIFIER genType ceilPowerOfTwo(genType value)
{ {
return detail::compute_ceilPowerOfTwo<1, genType, defaultp, tvec, std::numeric_limits<genType>::is_signed>::call(tvec1<genType, defaultp>(value)).x; return detail::compute_ceilPowerOfTwo<1, genType, defaultp, vec, std::numeric_limits<genType>::is_signed>::call(tvec1<genType, defaultp>(value)).x;
} }
template <int D, typename T, precision P, template <int, typename, precision> class vecType> template <int D, typename T, precision P, template <int, typename, precision> class vecType>

2
glm/gtx/type_trait.hpp
View File

@ -53,7 +53,7 @@ namespace glm
}; };
template <int D, typename T, precision P> template <int D, typename T, precision P>
struct type<tvec<D, T, P>> struct type<vec<D, T, P>>
{ {
static bool const is_vec = true; static bool const is_vec = true;
static bool const is_mat = false; static bool const is_mat = false;

12
glm/gtx/vector_query.inl
View File

@ -10,7 +10,7 @@ namespace detail
struct compute_areCollinear{}; struct compute_areCollinear{};
template <typename T, precision P> template <typename T, precision P>
struct compute_areCollinear<2, T, P, tvec> struct compute_areCollinear<2, T, P, vec>
{ {
GLM_FUNC_QUALIFIER static bool call(tvec2<T, P> const & v0, tvec2<T, P> const & v1, T const & epsilon) GLM_FUNC_QUALIFIER static bool call(tvec2<T, P> const & v0, tvec2<T, P> const & v1, T const & epsilon)
{ {
@ -19,7 +19,7 @@ namespace detail
}; };
template <typename T, precision P> template <typename T, precision P>
struct compute_areCollinear<3, T, P, tvec> struct compute_areCollinear<3, T, P, vec>
{ {
GLM_FUNC_QUALIFIER static bool call(tvec3<T, P> const & v0, tvec3<T, P> const & v1, T const & epsilon) GLM_FUNC_QUALIFIER static bool call(tvec3<T, P> const & v0, tvec3<T, P> const & v1, T const & epsilon)
{ {
@ -28,7 +28,7 @@ namespace detail
}; };
template <typename T, precision P> template <typename T, precision P>
struct compute_areCollinear<4, T, P, tvec> struct compute_areCollinear<4, T, P, vec>
{ {
GLM_FUNC_QUALIFIER static bool call(tvec4<T, P> const & v0, tvec4<T, P> const & v1, T const & epsilon) GLM_FUNC_QUALIFIER static bool call(tvec4<T, P> const & v0, tvec4<T, P> const & v1, T const & epsilon)
{ {
@ -40,7 +40,7 @@ namespace detail
struct compute_isCompNull{}; struct compute_isCompNull{};
template <typename T, precision P> template <typename T, precision P>
struct compute_isCompNull<2, T, P, tvec> struct compute_isCompNull<2, T, P, vec>
{ {
GLM_FUNC_QUALIFIER static tvec2<bool, P> call(tvec2<T, P> const & v, T const & epsilon) GLM_FUNC_QUALIFIER static tvec2<bool, P> call(tvec2<T, P> const & v, T const & epsilon)
{ {
@ -51,7 +51,7 @@ namespace detail
}; };
template <typename T, precision P> template <typename T, precision P>
struct compute_isCompNull<3, T, P, tvec> struct compute_isCompNull<3, T, P, vec>
{ {
GLM_FUNC_QUALIFIER static tvec3<bool, P> call(tvec3<T, P> const & v, T const & epsilon) GLM_FUNC_QUALIFIER static tvec3<bool, P> call(tvec3<T, P> const & v, T const & epsilon)
{ {
@ -63,7 +63,7 @@ namespace detail
}; };
template <typename T, precision P> template <typename T, precision P>
struct compute_isCompNull<4, T, P, tvec> struct compute_isCompNull<4, T, P, vec>
{ {
GLM_FUNC_QUALIFIER static tvec4<bool, P> call(tvec4<T, P> const & v, T const & epsilon) GLM_FUNC_QUALIFIER static tvec4<bool, P> call(tvec4<T, P> const & v, T const & epsilon)
{ {

6
test/core/core_func_integer.cpp
View File

@ -170,7 +170,7 @@ namespace bitfieldReverse
template <typename T> template <typename T>
GLM_FUNC_QUALIFIER T bitfieldReverseLoop(T v) GLM_FUNC_QUALIFIER T bitfieldReverseLoop(T v)
{ {
return bitfieldReverseLoop(glm::tvec<1, T>(v)).x; return bitfieldReverseLoop(glm::vec<1, T>(v)).x;
} }
GLM_FUNC_QUALIFIER glm::uint32_t bitfieldReverseUint32(glm::uint32_t x) GLM_FUNC_QUALIFIER glm::uint32_t bitfieldReverseUint32(glm::uint32_t x)
@ -230,7 +230,7 @@ namespace bitfieldReverse
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER genType bitfieldReverseOps(genType x) GLM_FUNC_QUALIFIER genType bitfieldReverseOps(genType x)
{ {
return bitfieldReverseOps(glm::tvec<1, genType, glm::defaultp>(x)).x; return bitfieldReverseOps(glm::vec<1, genType, glm::defaultp>(x)).x;
} }
template <typename genType> template <typename genType>
@ -1440,7 +1440,7 @@ namespace bitCount
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER int bitCount_bitfield(genType x) GLM_FUNC_QUALIFIER int bitCount_bitfield(genType x)
{ {
return bitCount_bitfield(glm::tvec<1, genType, glm::defaultp>(x)).x; return bitCount_bitfield(glm::vec<1, genType, glm::defaultp>(x)).x;
} }
int perf(std::size_t Size) int perf(std::size_t Size)