anulax
/
glm
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity

Clean up

Browse Source
master
Christophe Riccio ago%!(EXTRA string=11 years)
parent 372d75dbe8
commit 6eb5529395
6 changed files with 246 additions and 244 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      glm/detail/type_mat2x4.hpp
  2. 4
      glm/detail/type_mat2x4.inl
  3. 76
      glm/detail/type_vec4.hpp
  4. 292
      glm/detail/type_vec4.inl
  5. 110
      glm/gtc/vec1.hpp
  6. 4
      glm/gtc/vec1.inl

4
glm/detail/type_mat2x4.hpp
Unescape View File

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

4
glm/detail/type_mat2x4.inl
Unescape View File

@ -441,7 +441,7 @@ namespace glm
}
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>(
m[0] / s,
@ -449,7 +449,7 @@ namespace glm
}
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>(
s / m[0],

76
glm/detail/type_vec4.hpp
Unescape View File

@ -155,8 +155,8 @@ namespace detail
// Explicit basic constructors
GLM_FUNC_DECL explicit tvec4(ctor);
GLM_FUNC_DECL explicit tvec4(T const & s);
GLM_FUNC_DECL tvec4(T const & s0, T const & s1, T const & s2, T const & s3);
GLM_FUNC_DECL explicit tvec4(T s);
GLM_FUNC_DECL tvec4(T a, T b, T c, T d);
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)
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>
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)
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)
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);
//! 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>
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)
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);
//! 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>
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)
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);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
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)
template <typename A, typename B, precision Q>
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)
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)
template <typename A, typename B, precision Q>
GLM_FUNC_DECL explicit tvec4(tvec1<A, Q> const & a, tvec3<B, Q> const & b);
@ -261,25 +261,25 @@ namespace detail
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator=(tvec4<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator+=(U s);
GLM_FUNC_DECL tvec4<T, P> & operator+=(U scalar);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator+=(tvec1<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator+=(tvec4<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator-=(U s);
GLM_FUNC_DECL tvec4<T, P> & operator-=(U scalar);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator-=(tvec1<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator-=(tvec4<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator*=(U s);
GLM_FUNC_DECL tvec4<T, P> & operator*=(U scalar);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator*=(tvec1<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator*=(tvec4<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator/=(U s);
GLM_FUNC_DECL tvec4<T, P> & operator/=(U scalar);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator/=(tvec1<U, P> const & v);
template <typename U>
@ -297,37 +297,37 @@ namespace detail
// Unary bit operators
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator%=(U s);
GLM_FUNC_DECL tvec4<T, P> & operator%=(U scalar);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator%=(tvec1<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator%=(tvec4<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator&=(U s);
GLM_FUNC_DECL tvec4<T, P> & operator&=(U scalar);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator&=(tvec1<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator&=(tvec4<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator|=(U s);
GLM_FUNC_DECL tvec4<T, P> & operator|=(U scalar);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator|=(tvec1<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator|=(tvec4<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator^=(U s);
GLM_FUNC_DECL tvec4<T, P> & operator^=(U scalar);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator^=(tvec1<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator^=(tvec4<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator<<=(U s);
GLM_FUNC_DECL tvec4<T, P> & operator<<=(U scalar);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator<<=(tvec1<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator<<=(tvec4<U, P> const & v);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator>>=(U s);
GLM_FUNC_DECL tvec4<T, P> & operator>>=(U scalar);
template <typename U>
GLM_FUNC_DECL tvec4<T, P> & operator>>=(tvec1<U, P> const & v);
template <typename U>
@ -335,13 +335,13 @@ namespace detail
};
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>
GLM_FUNC_DECL tvec4<T, P> operator+(tvec4<T, P> const & v, tvec1<T, P> const & s);
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>
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);
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>
GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> const & v, tvec1<T, P> const & s);
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>
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);
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>
GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> const & v, tvec1<T, P> const & s);
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>
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);
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>
GLM_FUNC_DECL tvec4<T, P> operator/(tvec4<T, P> const & v, tvec1<T, P> const & s);
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>
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);
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>
GLM_FUNC_DECL tvec4<T, P> operator%(tvec4<T, P> const & v, tvec1<T, P> const & s);
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>
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);
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>
GLM_FUNC_DECL tvec4<T, P> operator&(tvec4<T, P> const & v, tvec1<T, P> const & s);
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>
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);
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>
GLM_FUNC_DECL tvec4<T, P> operator|(tvec4<T, P> const & v, tvec1<T, P> const & s);
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>
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);
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>
GLM_FUNC_DECL tvec4<T, P> operator^(tvec4<T, P> const & v, tvec1<T, P> const & s);
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>
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);
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>
GLM_FUNC_DECL tvec4<T, P> operator<<(tvec4<T, P> const & v, tvec1<T, P> const & s);
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>
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);
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>
GLM_FUNC_DECL tvec4<T, P> operator>>(tvec4<T, P> const & v, tvec1<T, P> const & s);
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>
GLM_FUNC_DECL tvec4<T, P> operator>>(tvec1<T, P> const & s, tvec4<T, P> const & v);

292
glm/detail/type_vec4.inl
Unescape View File

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

110
glm/gtc/vec1.hpp
Unescape View File

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

4
glm/gtc/vec1.inl
Unescape View File

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

Write Preview
Loading…
Cancel
Save