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

Clean up

Browse Source
This commit is contained in:
Christophe Riccio 2014-11-15 20:11:38 +01:00
parent 372d75dbe8
commit 6eb5529395
6 changed files with 246 additions and 244 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
glm/detail/type_mat2x4.hpp
View File

@ -189,11 +189,11 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tmat2x4<T, P> operator/ ( GLM_FUNC_DECL tmat2x4<T, P> operator/ (
tmat2x4<T, P> const & m, tmat2x4<T, P> const & m,
T const & s); T s);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tmat2x4<T, P> operator/ ( GLM_FUNC_DECL tmat2x4<T, P> operator/ (
T const & s, T s,
tmat2x4<T, P> const & m); tmat2x4<T, P> const & m);
// Unary constant operators // Unary constant operators

4
glm/detail/type_mat2x4.inl
View File

@ -441,7 +441,7 @@ namespace glm
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tmat2x4<T, P> operator/(tmat2x4<T, P> const & m, T const & s) GLM_FUNC_QUALIFIER tmat2x4<T, P> operator/(tmat2x4<T, P> const & m, T s)
{ {
return tmat2x4<T, P>( return tmat2x4<T, P>(
m[0] / s, m[0] / s,
@ -449,7 +449,7 @@ namespace glm
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tmat2x4<T, P> operator/(T const & s, tmat2x4<T, P> const & m) GLM_FUNC_QUALIFIER tmat2x4<T, P> operator/(T s, tmat2x4<T, P> const & m)
{ {
return tmat2x4<T, P>( return tmat2x4<T, P>(
s / m[0], s / m[0],

76
glm/detail/type_vec4.hpp
View File

@ -155,8 +155,8 @@ namespace detail
// Explicit basic constructors // Explicit basic constructors
GLM_FUNC_DECL explicit tvec4(ctor); GLM_FUNC_DECL explicit tvec4(ctor);
GLM_FUNC_DECL explicit tvec4(T const & s); GLM_FUNC_DECL explicit tvec4(T s);
GLM_FUNC_DECL tvec4(T const & s0, T const & s1, T const & s2, T const & s3); GLM_FUNC_DECL tvec4(T a, T b, T c, T d);
GLM_FUNC_DECL ~tvec4(){} GLM_FUNC_DECL ~tvec4(){}
////////////////////////////////////// //////////////////////////////////////
@ -164,7 +164,7 @@ namespace detail
/// 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 tvec4(A const & x, B const & y, C const & z, D const & w); GLM_FUNC_DECL tvec4(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 tvec4(tvec1<A, P> const & a, tvec1<B, P> const & b, tvec1<C, P> const & c, tvec1<D, P> const & d); GLM_FUNC_DECL tvec4(tvec1<A, P> const & a, tvec1<B, P> const & b, tvec1<C, P> const & c, tvec1<D, P> const & d);
@ -173,31 +173,31 @@ namespace detail
//! 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 explicit tvec4(tvec2<A, Q> const & a, B const & b, C const & c); GLM_FUNC_DECL explicit tvec4(tvec2<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 explicit tvec4(tvec2<A, Q> const & a, tvec1<B, Q> const & b, tvec1<C, Q> const & c); GLM_FUNC_DECL explicit tvec4(tvec2<A, Q> const & a, tvec1<B, Q> const & b, tvec1<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 explicit tvec4(A const & a, tvec2<B, Q> const & b, C const & c); GLM_FUNC_DECL explicit tvec4(A a, tvec2<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 explicit tvec4(tvec1<A, Q> const & a, tvec2<B, Q> const & b, tvec1<C, Q> const & c); GLM_FUNC_DECL explicit tvec4(tvec1<A, Q> const & a, tvec2<B, Q> const & b, tvec1<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 explicit tvec4(A const & a, B const & b, tvec2<C, Q> const & c); GLM_FUNC_DECL explicit tvec4(A a, B b, tvec2<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 explicit tvec4(tvec1<A, Q> const & a, tvec1<B, Q> const & b, tvec2<C, Q> const & c); GLM_FUNC_DECL explicit tvec4(tvec1<A, Q> const & a, tvec1<B, Q> const & b, tvec2<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 explicit tvec4(tvec3<A, Q> const & a, B const & b); GLM_FUNC_DECL explicit tvec4(tvec3<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 explicit tvec4(tvec3<A, Q> const & a, tvec1<B, Q> const & b); GLM_FUNC_DECL explicit tvec4(tvec3<A, Q> const & a, tvec1<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 explicit tvec4(A const & a, tvec3<B, Q> const & b); GLM_FUNC_DECL explicit tvec4(A a, tvec3<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 explicit tvec4(tvec1<A, Q> const & a, tvec3<B, Q> const & b); GLM_FUNC_DECL explicit tvec4(tvec1<A, Q> const & a, tvec3<B, Q> const & b);
@ -261,25 +261,25 @@ namespace detail
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator=(tvec4<U, P> const & v); GLM_FUNC_DECL tvec4<T, P> & operator=(tvec4<U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator+=(U s); GLM_FUNC_DECL tvec4<T, P> & operator+=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator+=(tvec1<U, P> const & v); GLM_FUNC_DECL tvec4<T, P> & operator+=(tvec1<U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator+=(tvec4<U, P> const & v); GLM_FUNC_DECL tvec4<T, P> & operator+=(tvec4<U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator-=(U s); GLM_FUNC_DECL tvec4<T, P> & operator-=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator-=(tvec1<U, P> const & v); GLM_FUNC_DECL tvec4<T, P> & operator-=(tvec1<U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator-=(tvec4<U, P> const & v); GLM_FUNC_DECL tvec4<T, P> & operator-=(tvec4<U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator*=(U s); GLM_FUNC_DECL tvec4<T, P> & operator*=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator*=(tvec1<U, P> const & v); GLM_FUNC_DECL tvec4<T, P> & operator*=(tvec1<U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator*=(tvec4<U, P> const & v); GLM_FUNC_DECL tvec4<T, P> & operator*=(tvec4<U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator/=(U s); GLM_FUNC_DECL tvec4<T, P> & operator/=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator/=(tvec1<U, P> const & v); GLM_FUNC_DECL tvec4<T, P> & operator/=(tvec1<U, P> const & v);
template <typename U> template <typename U>
@ -297,37 +297,37 @@ namespace detail
// Unary bit operators // Unary bit operators
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator%=(U s); GLM_FUNC_DECL tvec4<T, P> & operator%=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator%=(tvec1<U, P> const & v); GLM_FUNC_DECL tvec4<T, P> & operator%=(tvec1<U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator%=(tvec4<U, P> const & v); GLM_FUNC_DECL tvec4<T, P> & operator%=(tvec4<U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator&=(U s); GLM_FUNC_DECL tvec4<T, P> & operator&=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator&=(tvec1<U, P> const & v); GLM_FUNC_DECL tvec4<T, P> & operator&=(tvec1<U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator&=(tvec4<U, P> const & v); GLM_FUNC_DECL tvec4<T, P> & operator&=(tvec4<U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator|=(U s); GLM_FUNC_DECL tvec4<T, P> & operator|=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator|=(tvec1<U, P> const & v); GLM_FUNC_DECL tvec4<T, P> & operator|=(tvec1<U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator|=(tvec4<U, P> const & v); GLM_FUNC_DECL tvec4<T, P> & operator|=(tvec4<U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator^=(U s); GLM_FUNC_DECL tvec4<T, P> & operator^=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator^=(tvec1<U, P> const & v); GLM_FUNC_DECL tvec4<T, P> & operator^=(tvec1<U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator^=(tvec4<U, P> const & v); GLM_FUNC_DECL tvec4<T, P> & operator^=(tvec4<U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator<<=(U s); GLM_FUNC_DECL tvec4<T, P> & operator<<=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator<<=(tvec1<U, P> const & v); GLM_FUNC_DECL tvec4<T, P> & operator<<=(tvec1<U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator<<=(tvec4<U, P> const & v); GLM_FUNC_DECL tvec4<T, P> & operator<<=(tvec4<U, P> const & v);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator>>=(U s); GLM_FUNC_DECL tvec4<T, P> & operator>>=(U scalar);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator>>=(tvec1<U, P> const & v); GLM_FUNC_DECL tvec4<T, P> & operator>>=(tvec1<U, P> const & v);
template <typename U> template <typename U>
@ -335,13 +335,13 @@ namespace detail
}; };
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator+(tvec4<T, P> const & v, T const & s); GLM_FUNC_DECL tvec4<T, P> operator+(tvec4<T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator+(tvec4<T, P> const & v, tvec1<T, P> const & s); GLM_FUNC_DECL tvec4<T, P> operator+(tvec4<T, P> const & v, tvec1<T, P> const & s);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator+(T const & s, tvec4<T, P> const & v); GLM_FUNC_DECL tvec4<T, P> operator+(T scalar, tvec4<T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator+(tvec1<T, P> const & s, tvec4<T, P> const & v); GLM_FUNC_DECL tvec4<T, P> operator+(tvec1<T, P> const & s, tvec4<T, P> const & v);
@ -350,13 +350,13 @@ namespace detail
GLM_FUNC_DECL tvec4<T, P> operator+(tvec4<T, P> const & v1, tvec4<T, P> const & v2); GLM_FUNC_DECL tvec4<T, P> operator+(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> const & v, T const & s); GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> const & v, tvec1<T, P> const & s); GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> const & v, tvec1<T, P> const & s);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator-(T const & s, tvec4<T, P> const & v); GLM_FUNC_DECL tvec4<T, P> operator-(T scalar, tvec4<T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator-(tvec1<T, P> const & s, tvec4<T, P> const & v); GLM_FUNC_DECL tvec4<T, P> operator-(tvec1<T, P> const & s, tvec4<T, P> const & v);
@ -365,13 +365,13 @@ namespace detail
GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> const & v1, tvec4<T, P> const & v2); GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> const & v, T const & s); GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> const & v, tvec1<T, P> const & s); GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> const & v, tvec1<T, P> const & s);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator*(T const & s, tvec4<T, P> const & v); GLM_FUNC_DECL tvec4<T, P> operator*(T scalar, tvec4<T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator*(tvec1<T, P> const & s, tvec4<T, P> const & v); GLM_FUNC_DECL tvec4<T, P> operator*(tvec1<T, P> const & s, tvec4<T, P> const & v);
@ -380,13 +380,13 @@ namespace detail
GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> const & v1, tvec4<T, P> const & v2); GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator/(tvec4<T, P> const & v, T const & s); GLM_FUNC_DECL tvec4<T, P> operator/(tvec4<T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator/(tvec4<T, P> const & v, tvec1<T, P> const & s); GLM_FUNC_DECL tvec4<T, P> operator/(tvec4<T, P> const & v, tvec1<T, P> const & s);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator/(T const & s, tvec4<T, P> const & v); GLM_FUNC_DECL tvec4<T, P> operator/(T scalar, tvec4<T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator/(tvec1<T, P> const & s, tvec4<T, P> const & v); GLM_FUNC_DECL tvec4<T, P> operator/(tvec1<T, P> const & s, tvec4<T, P> const & v);
@ -404,13 +404,13 @@ namespace detail
GLM_FUNC_DECL bool operator!=(tvec4<T, P> const & v1, tvec4<T, P> const & v2); GLM_FUNC_DECL bool operator!=(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator%(tvec4<T, P> const & v, T const & s); GLM_FUNC_DECL tvec4<T, P> operator%(tvec4<T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator%(tvec4<T, P> const & v, tvec1<T, P> const & s); GLM_FUNC_DECL tvec4<T, P> operator%(tvec4<T, P> const & v, tvec1<T, P> const & s);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator%(T const & s, tvec4<T, P> const & v); GLM_FUNC_DECL tvec4<T, P> operator%(T scalar, tvec4<T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator%(tvec1<T, P> const & s, tvec4<T, P> const & v); GLM_FUNC_DECL tvec4<T, P> operator%(tvec1<T, P> const & s, tvec4<T, P> const & v);
@ -419,13 +419,13 @@ namespace detail
GLM_FUNC_DECL tvec4<T, P> operator%(tvec4<T, P> const & v1, tvec4<T, P> const & v2); GLM_FUNC_DECL tvec4<T, P> operator%(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator&(tvec4<T, P> const & v, T const & s); GLM_FUNC_DECL tvec4<T, P> operator&(tvec4<T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator&(tvec4<T, P> const & v, tvec1<T, P> const & s); GLM_FUNC_DECL tvec4<T, P> operator&(tvec4<T, P> const & v, tvec1<T, P> const & s);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator&(T const & s, tvec4<T, P> const & v); GLM_FUNC_DECL tvec4<T, P> operator&(T scalar, tvec4<T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator&(tvec1<T, P> const & s, tvec4<T, P> const & v); GLM_FUNC_DECL tvec4<T, P> operator&(tvec1<T, P> const & s, tvec4<T, P> const & v);
@ -434,13 +434,13 @@ namespace detail
GLM_FUNC_DECL tvec4<T, P> operator&(tvec4<T, P> const & v1, tvec4<T, P> const & v2); GLM_FUNC_DECL tvec4<T, P> operator&(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator|(tvec4<T, P> const & v, T const & s); GLM_FUNC_DECL tvec4<T, P> operator|(tvec4<T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator|(tvec4<T, P> const & v, tvec1<T, P> const & s); GLM_FUNC_DECL tvec4<T, P> operator|(tvec4<T, P> const & v, tvec1<T, P> const & s);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator|(T const & s, tvec4<T, P> const & v); GLM_FUNC_DECL tvec4<T, P> operator|(T scalar, tvec4<T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator|(tvec1<T, P> const & s, tvec4<T, P> const & v); GLM_FUNC_DECL tvec4<T, P> operator|(tvec1<T, P> const & s, tvec4<T, P> const & v);
@ -449,13 +449,13 @@ namespace detail
GLM_FUNC_DECL tvec4<T, P> operator|(tvec4<T, P> const & v1, tvec4<T, P> const & v2); GLM_FUNC_DECL tvec4<T, P> operator|(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator^(tvec4<T, P> const & v, T const & s); GLM_FUNC_DECL tvec4<T, P> operator^(tvec4<T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator^(tvec4<T, P> const & v, tvec1<T, P> const & s); GLM_FUNC_DECL tvec4<T, P> operator^(tvec4<T, P> const & v, tvec1<T, P> const & s);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator^(T const & s, tvec4<T, P> const & v); GLM_FUNC_DECL tvec4<T, P> operator^(T scalar, tvec4<T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator^(tvec1<T, P> const & s, tvec4<T, P> const & v); GLM_FUNC_DECL tvec4<T, P> operator^(tvec1<T, P> const & s, tvec4<T, P> const & v);
@ -464,13 +464,13 @@ namespace detail
GLM_FUNC_DECL tvec4<T, P> operator^(tvec4<T, P> const & v1, tvec4<T, P> const & v2); GLM_FUNC_DECL tvec4<T, P> operator^(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator<<(tvec4<T, P> const & v, T const & s); GLM_FUNC_DECL tvec4<T, P> operator<<(tvec4<T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator<<(tvec4<T, P> const & v, tvec1<T, P> const & s); GLM_FUNC_DECL tvec4<T, P> operator<<(tvec4<T, P> const & v, tvec1<T, P> const & s);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator<<(T const & s, tvec4<T, P> const & v); GLM_FUNC_DECL tvec4<T, P> operator<<(T scalar, tvec4<T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator<<(tvec1<T, P> const & s, tvec4<T, P> const & v); GLM_FUNC_DECL tvec4<T, P> operator<<(tvec1<T, P> const & s, tvec4<T, P> const & v);
@ -479,13 +479,13 @@ namespace detail
GLM_FUNC_DECL tvec4<T, P> operator<<(tvec4<T, P> const & v1, tvec4<T, P> const & v2); GLM_FUNC_DECL tvec4<T, P> operator<<(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator>>(tvec4<T, P> const & v, T const & s); GLM_FUNC_DECL tvec4<T, P> operator>>(tvec4<T, P> const & v, T scalar);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator>>(tvec4<T, P> const & v, tvec1<T, P> const & s); GLM_FUNC_DECL tvec4<T, P> operator>>(tvec4<T, P> const & v, tvec1<T, P> const & s);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator>>(T const & s, tvec4<T, P> const & v); GLM_FUNC_DECL tvec4<T, P> operator>>(T scalar, tvec4<T, P> const & v);
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_DECL tvec4<T, P> operator>>(tvec1<T, P> const & s, tvec4<T, P> const & v); GLM_FUNC_DECL tvec4<T, P> operator>>(tvec1<T, P> const & s, tvec4<T, P> const & v);

292
glm/detail/type_vec4.inl
View File

@ -99,35 +99,35 @@ namespace glm
{} {}
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(T const & s) GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(T s)
: x(s), y(s), z(s), w(s) : x(s), y(s), z(s), w(s)
{} {}
#if GLM_HAS_ANONYMOUS_UNION && (GLM_ARCH & GLM_ARCH_SSE2) #if GLM_HAS_ANONYMOUS_UNION && (GLM_ARCH & GLM_ARCH_SSE2)
template <> template <>
GLM_FUNC_QUALIFIER tvec4<float, lowp>::tvec4(float const & s) : GLM_FUNC_QUALIFIER tvec4<float, lowp>::tvec4(float s) :
data(_mm_set1_ps(s)) data(_mm_set1_ps(s))
{} {}
template <> template <>
GLM_FUNC_QUALIFIER tvec4<float, mediump>::tvec4(float const & s) : GLM_FUNC_QUALIFIER tvec4<float, mediump>::tvec4(float s) :
data(_mm_set1_ps(s)) data(_mm_set1_ps(s))
{} {}
#endif #endif
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(T const & a, T const & b, T const & c, T const & d) GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(T a, T b, T c, T d)
: x(a), y(b), z(c), w(d) : x(a), y(b), z(c), w(d)
{} {}
#if GLM_HAS_ANONYMOUS_UNION && (GLM_ARCH & GLM_ARCH_SSE2) #if GLM_HAS_ANONYMOUS_UNION && (GLM_ARCH & GLM_ARCH_SSE2)
template <> template <>
GLM_FUNC_QUALIFIER tvec4<float, lowp>::tvec4(float const & a, float const & b, float const & c, float const & d) : GLM_FUNC_QUALIFIER tvec4<float, lowp>::tvec4(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 tvec4<float, mediump>::tvec4(float const & a, float const & b, float const & c, float const & d) : GLM_FUNC_QUALIFIER tvec4<float, mediump>::tvec4(float a, float b, float c, float d) :
data(_mm_set_ps(d, c, b, a)) data(_mm_set_ps(d, c, b, a))
{} {}
#endif #endif
@ -137,7 +137,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename A, typename B, typename C, typename D> template <typename A, typename B, typename C, typename D>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(A const & a, B const & b, C const & c, D const & d) : GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(A a, B b, C c, D d) :
x(static_cast<T>(a)), x(static_cast<T>(a)),
y(static_cast<T>(b)), y(static_cast<T>(b)),
z(static_cast<T>(c)), z(static_cast<T>(c)),
@ -158,7 +158,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename A, typename B, typename C, precision Q> template <typename A, typename B, typename C, precision Q>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(tvec2<A, Q> const & a, B const & b, C const & c) : GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(tvec2<A, Q> const & a, B b, C c) :
x(static_cast<T>(a.x)), x(static_cast<T>(a.x)),
y(static_cast<T>(a.y)), y(static_cast<T>(a.y)),
z(static_cast<T>(b)), z(static_cast<T>(b)),
@ -176,7 +176,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename A, typename B, typename C, precision Q> template <typename A, typename B, typename C, precision Q>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(A const & s1, tvec2<B, Q> const & v, C const & s2) : GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(A s1, tvec2<B, Q> const & v, C s2) :
x(static_cast<T>(s1)), x(static_cast<T>(s1)),
y(static_cast<T>(v.x)), y(static_cast<T>(v.x)),
z(static_cast<T>(v.y)), z(static_cast<T>(v.y)),
@ -194,7 +194,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename A, typename B, typename C, precision Q> template <typename A, typename B, typename C, precision Q>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(A const & s1, B const & s2, tvec2<C, Q> const & v) : GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(A s1, B s2, tvec2<C, Q> const & v) :
x(static_cast<T>(s1)), x(static_cast<T>(s1)),
y(static_cast<T>(s2)), y(static_cast<T>(s2)),
z(static_cast<T>(v.x)), z(static_cast<T>(v.x)),
@ -212,7 +212,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename A, typename B, precision Q> template <typename A, typename B, precision Q>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(tvec3<A, Q> const & a, B const & b) : GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(tvec3<A, Q> const & a, B b) :
x(static_cast<T>(a.x)), x(static_cast<T>(a.x)),
y(static_cast<T>(a.y)), y(static_cast<T>(a.y)),
z(static_cast<T>(a.z)), z(static_cast<T>(a.z)),
@ -230,7 +230,7 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename A, typename B, precision Q> template <typename A, typename B, precision Q>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(A const & a, tvec3<B, Q> const & b) : GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(A a, tvec3<B, Q> const & b) :
x(static_cast<T>(a)), x(static_cast<T>(a)),
y(static_cast<T>(b.x)), y(static_cast<T>(b.x)),
z(static_cast<T>(b.y)), z(static_cast<T>(b.y)),
@ -280,74 +280,75 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator+=(U s) GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator+=(U scalar)
{ {
this->x += static_cast<T>(s); this->x += static_cast<T>(scalar);
this->y += static_cast<T>(s); this->y += static_cast<T>(scalar);
this->z += static_cast<T>(s); this->z += static_cast<T>(scalar);
this->w += static_cast<T>(s); this->w += static_cast<T>(scalar);
return *this; return *this;
} }
#if GLM_HAS_ANONYMOUS_UNION && (GLM_ARCH & GLM_ARCH_SSE2) #if GLM_HAS_ANONYMOUS_UNION && (GLM_ARCH & GLM_ARCH_SSE2)
template <> template <>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec4<float, lowp> & tvec4<float, lowp>::operator+=(U s) GLM_FUNC_QUALIFIER tvec4<float, lowp> & tvec4<float, lowp>::operator+=(U scalar)
{ {
this->data = _mm_add_ps(this->data, _mm_set_ps1(static_cast<float>(s))); this->data = _mm_add_ps(this->data, _mm_set_ps1(static_cast<float>(scalar)));
return *this; return *this;
} }
template <> template <>
template <> template <>
GLM_FUNC_QUALIFIER tvec4<float, lowp> & tvec4<float, lowp>::operator+=<float>(float s) GLM_FUNC_QUALIFIER tvec4<float, lowp> & tvec4<float, lowp>::operator+=<float>(float scalar)
{ {
this->data = _mm_add_ps(this->data, _mm_set_ps1(s)); this->data = _mm_add_ps(this->data, _mm_set_ps1(scalar));
return *this; return *this;
} }
template <> template <>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec4<float, mediump> & tvec4<float, mediump>::operator+=(U s) GLM_FUNC_QUALIFIER tvec4<float, mediump> & tvec4<float, mediump>::operator+=(U scalar)
{ {
this->data = _mm_add_ps(this->data, _mm_set_ps1(static_cast<float>(s))); this->data = _mm_add_ps(this->data, _mm_set_ps1(static_cast<float>(scalar)));
return *this; return *this;
} }
template <> template <>
template <> template <>
GLM_FUNC_QUALIFIER tvec4<float, mediump> & tvec4<float, mediump>::operator+=<float>(float s) GLM_FUNC_QUALIFIER tvec4<float, mediump> & tvec4<float, mediump>::operator+=<float>(float scalar)
{ {
this->data = _mm_add_ps(this->data, _mm_set_ps1(s)); this->data = _mm_add_ps(this->data, _mm_set_ps1(scalar));
return *this; return *this;
} }
#endif #endif
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator+=(tvec1<U, P> const & s) GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator+=(tvec1<U, P> const & v)
{ {
this->x += static_cast<T>(s); T const scalar = static_cast<T>(v.x);
this->y += static_cast<T>(s); this->x += scalar;
this->z += static_cast<T>(s); this->y += scalar;
this->w += static_cast<T>(s); this->z += scalar;
this->w += scalar;
return *this; return *this;
} }
#if GLM_HAS_ANONYMOUS_UNION && (GLM_ARCH & GLM_ARCH_SSE2) #if GLM_HAS_ANONYMOUS_UNION && (GLM_ARCH & GLM_ARCH_SSE2)
template <> template <>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec4<float, lowp> & tvec4<float, lowp>::operator+=(tvec1<U, lowp> const & s) GLM_FUNC_QUALIFIER tvec4<float, lowp> & tvec4<float, lowp>::operator+=(tvec1<U, lowp> const & v)
{ {
this->data = _mm_add_ps(this->data, _mm_set_ps1(static_cast<float>(s))); this->data = _mm_add_ps(this->data, _mm_set_ps1(static_cast<float>(v.x)));
return *this; return *this;
} }
template <> template <>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec4<float, mediump> & tvec4<float, mediump>::operator+=(tvec1<U, mediump> const & s) GLM_FUNC_QUALIFIER tvec4<float, mediump> & tvec4<float, mediump>::operator+=(tvec1<U, mediump> const & v)
{ {
this->data = _mm_add_ps(this->data, _mm_set_ps1(static_cast<float>(s))); this->data = _mm_add_ps(this->data, _mm_set_ps1(static_cast<float>(v.x)));
return *this; return *this;
} }
#endif #endif
@ -365,12 +366,12 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator-=(U s) GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator-=(U scalar)
{ {
this->x -= static_cast<T>(s); this->x -= static_cast<T>(scalar);
this->y -= static_cast<T>(s); this->y -= static_cast<T>(scalar);
this->z -= static_cast<T>(s); this->z -= static_cast<T>(scalar);
this->w -= static_cast<T>(s); this->w -= static_cast<T>(scalar);
return *this; return *this;
} }
@ -378,10 +379,11 @@ namespace glm
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator-=(tvec1<U, P> const & v) GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator-=(tvec1<U, P> const & v)
{ {
this->x -= static_cast<T>(v.x); T const scalar = static_cast<T>(v.x);
this->y -= static_cast<T>(v.x); this->x -= scalar;
this->z -= static_cast<T>(v.x); this->y -= scalar;
this->w -= static_cast<T>(v.x); this->z -= scalar;
this->w -= scalar;
return *this; return *this;
} }
@ -506,12 +508,12 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator%=(U s) GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator%=(U scalar)
{ {
this->x %= static_cast<T>(s); this->x %= static_cast<T>(scalar);
this->y %= static_cast<T>(s); this->y %= static_cast<T>(scalar);
this->z %= static_cast<T>(s); this->z %= static_cast<T>(scalar);
this->w %= static_cast<T>(s); this->w %= static_cast<T>(scalar);
return *this; return *this;
} }
@ -539,12 +541,12 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator&=(U s) GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator&=(U scalar)
{ {
this->x &= static_cast<T>(s); this->x &= static_cast<T>(scalar);
this->y &= static_cast<T>(s); this->y &= static_cast<T>(scalar);
this->z &= static_cast<T>(s); this->z &= static_cast<T>(scalar);
this->w &= static_cast<T>(s); this->w &= static_cast<T>(scalar);
return *this; return *this;
} }
@ -572,12 +574,12 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator|=(U s) GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator|=(U scalar)
{ {
this->x |= static_cast<T>(s); this->x |= static_cast<T>(scalar);
this->y |= static_cast<T>(s); this->y |= static_cast<T>(scalar);
this->z |= static_cast<T>(s); this->z |= static_cast<T>(scalar);
this->w |= static_cast<T>(s); this->w |= static_cast<T>(scalar);
return *this; return *this;
} }
@ -605,12 +607,12 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator^=(U s) GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator^=(U scalar)
{ {
this->x ^= static_cast<T>(s); this->x ^= static_cast<T>(scalar);
this->y ^= static_cast<T>(s); this->y ^= static_cast<T>(scalar);
this->z ^= static_cast<T>(s); this->z ^= static_cast<T>(scalar);
this->w ^= static_cast<T>(s); this->w ^= static_cast<T>(scalar);
return *this; return *this;
} }
@ -638,12 +640,12 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator<<=(U s) GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator<<=(U scalar)
{ {
this->x <<= static_cast<T>(s); this->x <<= static_cast<T>(scalar);
this->y <<= static_cast<T>(s); this->y <<= static_cast<T>(scalar);
this->z <<= static_cast<T>(s); this->z <<= static_cast<T>(scalar);
this->w <<= static_cast<T>(s); this->w <<= static_cast<T>(scalar);
return *this; return *this;
} }
@ -671,12 +673,12 @@ namespace glm
template <typename T, precision P> template <typename T, precision P>
template <typename U> template <typename U>
GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator>>=(U s) GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator>>=(U scalar)
{ {
this->x >>= static_cast<T>(s); this->x >>= static_cast<T>(scalar);
this->y >>= static_cast<T>(s); this->y >>= static_cast<T>(scalar);
this->z >>= static_cast<T>(s); this->z >>= static_cast<T>(scalar);
this->w >>= static_cast<T>(s); this->w >>= static_cast<T>(scalar);
return *this; return *this;
} }
@ -721,23 +723,23 @@ namespace glm
// Binary arithmetic operators // Binary arithmetic operators
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> operator+(tvec4<T, P> const & v, T const & s) GLM_FUNC_QUALIFIER tvec4<T, P> operator+(tvec4<T, P> const & v, T scalar)
{ {
return tvec4<T, P>( return tvec4<T, P>(
v.x + s, v.x + scalar,
v.y + s, v.y + scalar,
v.z + s, v.z + scalar,
v.w + s); v.w + scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> operator+(T const & s, tvec4<T, P> const & v) GLM_FUNC_QUALIFIER tvec4<T, P> operator+(T scalar, tvec4<T, P> const & v)
{ {
return tvec4<T, P>( return tvec4<T, P>(
s + v.x, scalar + v.x,
s + v.y, scalar + v.y,
s + v.z, scalar + v.z,
s + v.w); scalar + v.w);
} }
template <typename T, precision P> template <typename T, precision P>
@ -752,23 +754,23 @@ namespace glm
//operator- //operator-
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> operator-(tvec4<T, P> const & v, T const & s) GLM_FUNC_QUALIFIER tvec4<T, P> operator-(tvec4<T, P> const & v, T scalar)
{ {
return tvec4<T, P>( return tvec4<T, P>(
v.x - s, v.x - scalar,
v.y - s, v.y - scalar,
v.z - s, v.z - scalar,
v.w - s); v.w - scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> operator-(T const & s, tvec4<T, P> const & v) GLM_FUNC_QUALIFIER tvec4<T, P> operator-(T scalar, tvec4<T, P> const & v)
{ {
return tvec4<T, P>( return tvec4<T, P>(
s - v.x, scalar - v.x,
s - v.y, scalar - v.y,
s - v.z, scalar - v.z,
s - v.w); scalar - v.w);
} }
template <typename T, precision P> template <typename T, precision P>
@ -783,23 +785,23 @@ namespace glm
//operator* //operator*
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> operator*(tvec4<T, P> const & v, T const & s) GLM_FUNC_QUALIFIER tvec4<T, P> operator*(tvec4<T, P> const & v, T scalar)
{ {
return tvec4<T, P>( return tvec4<T, P>(
v.x * s, v.x * scalar,
v.y * s, v.y * scalar,
v.z * s, v.z * scalar,
v.w * s); v.w * scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> operator*(T const & s, tvec4<T, P> const & v) GLM_FUNC_QUALIFIER tvec4<T, P> operator*(T scalar, tvec4<T, P> const & v)
{ {
return tvec4<T, P>( return tvec4<T, P>(
s * v.x, scalar * v.x,
s * v.y, scalar * v.y,
s * v.z, scalar * v.z,
s * v.w); scalar * v.w);
} }
template <typename T, precision P> template <typename T, precision P>
@ -814,23 +816,23 @@ namespace glm
//operator/ //operator/
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> operator/(tvec4<T, P> const & v, T const & s) GLM_FUNC_QUALIFIER tvec4<T, P> operator/(tvec4<T, P> const & v, T scalar)
{ {
return tvec4<T, P>( return tvec4<T, P>(
v.x / s, v.x / scalar,
v.y / s, v.y / scalar,
v.z / s, v.z / scalar,
v.w / s); v.w / scalar);
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> operator/(T const & s, tvec4<T, P> const & v) GLM_FUNC_QUALIFIER tvec4<T, P> operator/(T scalar, tvec4<T, P> const & v)
{ {
return tvec4<T, P>( return tvec4<T, P>(
s / v.x, scalar / v.x,
s / v.y, scalar / v.y,
s / v.z, scalar / v.z,
s / v.w); scalar / v.w);
} }
template <typename T, precision P> template <typename T, precision P>
@ -858,7 +860,7 @@ namespace glm
// Binary bit operators // Binary bit operators
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> operator%(tvec4<T, P> const & v, T const & s) GLM_FUNC_QUALIFIER tvec4<T, P> operator%(tvec4<T, P> const & v, T s)
{ {
return tvec4<T, P>( return tvec4<T, P>(
v.x % s, v.x % s,
@ -878,7 +880,7 @@ namespace glm
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> operator%(T const & s, tvec4<T, P> const & v) GLM_FUNC_QUALIFIER tvec4<T, P> operator%(T s, tvec4<T, P> const & v)
{ {
return tvec4<T, P>( return tvec4<T, P>(
s % v.x, s % v.x,
@ -908,7 +910,7 @@ namespace glm
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> operator&(tvec4<T, P> const & v, T const & s) GLM_FUNC_QUALIFIER tvec4<T, P> operator&(tvec4<T, P> const & v, T s)
{ {
return tvec4<T, P>( return tvec4<T, P>(
v.x & s, v.x & s,
@ -928,7 +930,7 @@ namespace glm
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> operator&(T const & s, tvec4<T, P> const & v) GLM_FUNC_QUALIFIER tvec4<T, P> operator&(T s, tvec4<T, P> const & v)
{ {
return tvec4<T, P>( return tvec4<T, P>(
s & v.x, s & v.x,
@ -958,7 +960,7 @@ namespace glm
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> operator|(tvec4<T, P> const & v, T const & s) GLM_FUNC_QUALIFIER tvec4<T, P> operator|(tvec4<T, P> const & v, T s)
{ {
return tvec4<T, P>( return tvec4<T, P>(
v.x | s, v.x | s,
@ -978,7 +980,7 @@ namespace glm
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> operator|(T const & s, tvec4<T, P> const & v) GLM_FUNC_QUALIFIER tvec4<T, P> operator|(T s, tvec4<T, P> const & v)
{ {
return tvec4<T, P>( return tvec4<T, P>(
s | v.x, s | v.x,
@ -1008,7 +1010,7 @@ namespace glm
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> operator^(tvec4<T, P> const & v, T const & s) GLM_FUNC_QUALIFIER tvec4<T, P> operator^(tvec4<T, P> const & v, T s)
{ {
return tvec4<T, P>( return tvec4<T, P>(
v.x ^ s, v.x ^ s,
@ -1028,13 +1030,13 @@ namespace glm
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> operator^(T const & s, tvec4<T, P> const & v) GLM_FUNC_QUALIFIER tvec4<T, P> operator^(T scalar, tvec4<T, P> const & v)
{ {
return tvec4<T, P>( return tvec4<T, P>(
s ^ v.x, scalar ^ v.x,
s ^ v.y, scalar ^ v.y,
s ^ v.z, scalar ^ v.z,
s ^ v.w); scalar ^ v.w);
} }
template <typename T, precision P> template <typename T, precision P>
@ -1058,13 +1060,13 @@ namespace glm
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> operator<<(tvec4<T, P> const & v, T const & s) GLM_FUNC_QUALIFIER tvec4<T, P> operator<<(tvec4<T, P> const & left, T scalar)
{ {
return tvec4<T, P>( return tvec4<T, P>(
v.x << s, v.x << scalar,
v.y << s, v.y << scalar,
v.z << s, v.z << scalar,
v.w << s); v.w << scalar);
} }
template <typename T, precision P> template <typename T, precision P>
@ -1078,13 +1080,13 @@ namespace glm
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> operator<<(T const & s, tvec4<T, P> const & v) GLM_FUNC_QUALIFIER tvec4<T, P> operator<<(T scalar, tvec4<T, P> const & v)
{ {
return tvec4<T, P>( return tvec4<T, P>(
s << v.x, scalar << v.x,
s << v.y, scalar << v.y,
s << v.z, scalar << v.z,
s << v.w); scalar << v.w);
} }
template <typename T, precision P> template <typename T, precision P>
@ -1108,13 +1110,13 @@ namespace glm
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> operator>>(tvec4<T, P> const & v, T const & s) GLM_FUNC_QUALIFIER tvec4<T, P> operator>>(tvec4<T, P> const & v, T scalar)
{ {
return tvec4<T, P>( return tvec4<T, P>(
v.x >> s, v.x >> scalar,
v.y >> s, v.y >> scalar,
v.z >> s, v.z >> scalar,
v.w >> s); v.w >> scalar);
} }
template <typename T, precision P> template <typename T, precision P>
@ -1128,13 +1130,13 @@ namespace glm
} }
template <typename T, precision P> template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> operator>>(T const & s, tvec4<T, P> const & v) GLM_FUNC_QUALIFIER tvec4<T, P> operator>>(T scalar, tvec4<T, P> const & v)
{ {
return tvec4<T, P>( return tvec4<T, P>(
s >> v.x, scalar >> v.x,
s >> v.y, scalar >> v.y,
s >> v.z, scalar >> v.z,
s >> v.w); scalar >> v.w);
} }
template <typename T, precision P> template <typename T, precision P>

110
glm/gtc/vec1.hpp
View File

@ -20,18 +20,18 @@
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN /// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE. /// THE SOFTWARE.
/// ///
/// @ref gtx_vec1 /// @ref gtc_vec1
/// @file glm/gtx/vec1.hpp /// @file glm/gtc/vec1.hpp
/// @date 2010-02-08 / 2011-06-07 /// @date 2010-02-08 / 2011-06-07
/// @author Christophe Riccio /// @author Christophe Riccio
/// ///
/// @see core (dependence) /// @see core (dependence)
/// ///
/// @defgroup gtx_vec1 GLM_GTX_vec1 /// @defgroup gtc_vec1 GLM_GTX_vec1
/// @ingroup gtx /// @ingroup gtx
/// ///
/// @brief Add vec1, ivec1, uvec1 and bvec1 types. /// @brief Add vec1, ivec1, uvec1 and bvec1 types.
/// <glm/gtx/vec1.hpp> need to be included to use these functionalities. /// <glm/gtc/vec1.hpp> need to be included to use these functionalities.
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
#pragma once #pragma once
@ -41,84 +41,84 @@
#include "../detail/type_vec1.hpp" #include "../detail/type_vec1.hpp"
#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED)) #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
# pragma message("GLM: GLM_GTX_vec1 extension included") # pragma message("GLM: GLM_GTC_vec1 extension included")
#endif #endif
namespace glm namespace glm
{ {
//! 1 component vector of high precision floating-point numbers. /// 1 component vector of high precision floating-point numbers.
//! There is no guarantee on the actual precision. /// There is no guarantee on the actual precision.
/// @see gtx_vec1 extension. /// @see gtc_vec1 extension.
typedef highp_vec1_t highp_vec1; typedef highp_vec1_t highp_vec1;
//! 1 component vector of medium precision floating-point numbers. /// 1 component vector of medium precision floating-point numbers.
//! There is no guarantee on the actual precision. /// There is no guarantee on the actual precision.
/// @see gtx_vec1 extension. /// @see gtc_vec1 extension.
typedef mediump_vec1_t mediump_vec1; typedef mediump_vec1_t mediump_vec1;
//! 1 component vector of low precision floating-point numbers. /// 1 component vector of low precision floating-point numbers.
//! There is no guarantee on the actual precision. /// There is no guarantee on the actual precision.
/// @see gtx_vec1 extension. /// @see gtc_vec1 extension.
typedef lowp_vec1_t lowp_vec1; typedef lowp_vec1_t lowp_vec1;
//! 1 component vector of high precision floating-point numbers. /// 1 component vector of high precision floating-point numbers.
//! There is no guarantee on the actual precision. /// There is no guarantee on the actual precision.
/// @see gtx_vec1 extension. /// @see gtc_vec1 extension.
typedef highp_dvec1_t highp_dvec1; typedef highp_dvec1_t highp_dvec1;
//! 1 component vector of medium precision floating-point numbers. /// 1 component vector of medium precision floating-point numbers.
//! There is no guarantee on the actual precision. /// There is no guarantee on the actual precision.
/// @see gtx_vec1 extension. /// @see gtc_vec1 extension.
typedef mediump_dvec1_t mediump_dvec1; typedef mediump_dvec1_t mediump_dvec1;
//! 1 component vector of low precision floating-point numbers. /// 1 component vector of low precision floating-point numbers.
//! There is no guarantee on the actual precision. /// There is no guarantee on the actual precision.
/// @see gtx_vec1 extension. /// @see gtc_vec1 extension.
typedef lowp_dvec1_t lowp_dvec1; typedef lowp_dvec1_t lowp_dvec1;
//! 1 component vector of high precision signed integer numbers. /// 1 component vector of high precision signed integer numbers.
//! There is no guarantee on the actual precision. /// There is no guarantee on the actual precision.
/// @see gtx_vec1 extension. /// @see gtc_vec1 extension.
typedef highp_ivec1_t highp_ivec1; typedef highp_ivec1_t highp_ivec1;
//! 1 component vector of medium precision signed integer numbers. /// 1 component vector of medium precision signed integer numbers.
//! There is no guarantee on the actual precision. /// There is no guarantee on the actual precision.
/// @see gtx_vec1 extension. /// @see gtc_vec1 extension.
typedef mediump_ivec1_t mediump_ivec1; typedef mediump_ivec1_t mediump_ivec1;
//! 1 component vector of low precision signed integer numbers. /// 1 component vector of low precision signed integer numbers.
//! There is no guarantee on the actual precision. /// There is no guarantee on the actual precision.
/// @see gtx_vec1 extension. /// @see gtc_vec1 extension.
typedef lowp_ivec1_t lowp_ivec1; typedef lowp_ivec1_t lowp_ivec1;
//! 1 component vector of high precision unsigned integer numbers. /// 1 component vector of high precision unsigned integer numbers.
//! There is no guarantee on the actual precision. /// There is no guarantee on the actual precision.
/// @see gtx_vec1 extension. /// @see gtc_vec1 extension.
typedef highp_uvec1_t highp_uvec1; typedef highp_uvec1_t highp_uvec1;
//! 1 component vector of medium precision unsigned integer numbers. /// 1 component vector of medium precision unsigned integer numbers.
//! There is no guarantee on the actual precision. /// There is no guarantee on the actual precision.
/// @see gtx_vec1 extension. /// @see gtc_vec1 extension.
typedef mediump_uvec1_t mediump_uvec1; typedef mediump_uvec1_t mediump_uvec1;
//! 1 component vector of low precision unsigned integer numbers. /// 1 component vector of low precision unsigned integer numbers.
//! There is no guarantee on the actual precision. /// There is no guarantee on the actual precision.
/// @see gtx_vec1 extension. /// @see gtc_vec1 extension.
typedef lowp_uvec1_t lowp_uvec1; typedef lowp_uvec1_t lowp_uvec1;
//! 1 component vector of high precision boolean. /// 1 component vector of high precision boolean.
//! There is no guarantee on the actual precision. /// There is no guarantee on the actual precision.
/// @see gtx_vec1 extension. /// @see gtc_vec1 extension.
typedef highp_bvec1_t highp_bvec1; typedef highp_bvec1_t highp_bvec1;
//! 1 component vector of medium precision boolean. /// 1 component vector of medium precision boolean.
//! There is no guarantee on the actual precision. /// There is no guarantee on the actual precision.
/// @see gtx_vec1 extension. /// @see gtc_vec1 extension.
typedef mediump_bvec1_t mediump_bvec1; typedef mediump_bvec1_t mediump_bvec1;
//! 1 component vector of low precision boolean. /// 1 component vector of low precision boolean.
//! There is no guarantee on the actual precision. /// There is no guarantee on the actual precision.
/// @see gtx_vec1 extension. /// @see gtc_vec1 extension.
typedef lowp_bvec1_t lowp_bvec1; typedef lowp_bvec1_t lowp_bvec1;
////////////////////////// //////////////////////////
@ -132,7 +132,7 @@ namespace glm
typedef lowp_bvec1 bvec1; typedef lowp_bvec1 bvec1;
#else #else
/// 1 component vector of boolean. /// 1 component vector of boolean.
/// @see gtx_vec1 extension. /// @see gtc_vec1 extension.
typedef highp_bvec1 bvec1; typedef highp_bvec1 bvec1;
#endif//GLM_PRECISION #endif//GLM_PRECISION
@ -144,7 +144,7 @@ namespace glm
typedef lowp_vec1 vec1; typedef lowp_vec1 vec1;
#else #else
/// 1 component vector of floating-point numbers. /// 1 component vector of floating-point numbers.
/// @see gtx_vec1 extension. /// @see gtc_vec1 extension.
typedef highp_vec1 vec1; typedef highp_vec1 vec1;
#endif//GLM_PRECISION #endif//GLM_PRECISION
@ -156,7 +156,7 @@ namespace glm
typedef lowp_dvec1 dvec1; typedef lowp_dvec1 dvec1;
#else #else
/// 1 component vector of floating-point numbers. /// 1 component vector of floating-point numbers.
/// @see gtx_vec1 extension. /// @see gtc_vec1 extension.
typedef highp_dvec1 dvec1; typedef highp_dvec1 dvec1;
#endif//GLM_PRECISION #endif//GLM_PRECISION
@ -168,7 +168,7 @@ namespace glm
typedef lowp_ivec1 ivec1; typedef lowp_ivec1 ivec1;
#else #else
/// 1 component vector of signed integer numbers. /// 1 component vector of signed integer numbers.
/// @see gtx_vec1 extension. /// @see gtc_vec1 extension.
typedef highp_ivec1 ivec1; typedef highp_ivec1 ivec1;
#endif//GLM_PRECISION #endif//GLM_PRECISION
@ -180,7 +180,7 @@ namespace glm
typedef lowp_uvec1 uvec1; typedef lowp_uvec1 uvec1;
#else #else
/// 1 component vector of unsigned integer numbers. /// 1 component vector of unsigned integer numbers.
/// @see gtx_vec1 extension. /// @see gtc_vec1 extension.
typedef highp_uvec1 uvec1; typedef highp_uvec1 uvec1;
#endif//GLM_PRECISION #endif//GLM_PRECISION

4
glm/gtc/vec1.inl
View File

@ -20,8 +20,8 @@
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN /// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE. /// THE SOFTWARE.
/// ///
/// @ref gtx_vec1 /// @ref gtc_vec1
/// @file glm/gtx/vec1.inl /// @file glm/gtc/vec1.inl
/// @date 2013-03-16 / 2013-03-16 /// @date 2013-03-16 / 2013-03-16
/// @author Christophe Riccio /// @author Christophe Riccio
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////