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

Remove tref*

Browse Source
This commit is contained in:
Christophe Riccio 2013-09-16 00:39:19 +02:00
parent 3e82b598b4
commit 8eea3c7645
18 changed files with 44 additions and 593 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
glm/core/dummy.cpp
View File

@ -55,16 +55,26 @@ int test_simd()
#endif//GLM_ARCH
*/
template <class T = int>
class C;
template <class T>
class C
{
public:
T value;
};
int main()
{
glm::mat4 A(1.0f);
glm::vec4 B(1.0f);
glm::vec4 C = A * B;
/*
# if(GLM_ARCH & GLM_ARCH_SSE2)
test_simd();
# endif
*/
C<> c;
return 0;
}

2
glm/core/type_mat2x2.hpp
View File

@ -35,7 +35,7 @@
namespace glm{
namespace detail
{
template <typename T = float, precision P = defaultp>
template <typename T, precision P>
struct tmat2x2
{
// Implementation detail

2
glm/core/type_mat2x3.hpp
View File

@ -35,7 +35,7 @@
namespace glm{
namespace detail
{
template <typename T = float, precision P = defaultp>
template <typename T, precision P>
struct tmat2x3
{
enum ctor{_null};

2
glm/core/type_mat2x4.hpp
View File

@ -35,7 +35,7 @@
namespace glm{
namespace detail
{
template <typename T = float, precision P = defaultp>
template <typename T, precision P>
struct tmat2x4
{
enum ctor{_null};

2
glm/core/type_mat3x2.hpp
View File

@ -35,7 +35,7 @@
namespace glm{
namespace detail
{
template <typename T = float, precision P = defaultp>
template <typename T, precision P>
struct tmat3x2
{
enum ctor{_null};

2
glm/core/type_mat3x3.hpp
View File

@ -35,7 +35,7 @@
namespace glm{
namespace detail
{
template <typename T = float, precision P = defaultp>
template <typename T, precision P>
struct tmat3x3
{
enum ctor{_null};

2
glm/core/type_mat3x4.hpp
View File

@ -35,7 +35,7 @@
namespace glm{
namespace detail
{
template <typename T = float, precision P = defaultp>
template <typename T, precision P>
struct tmat3x4
{
enum ctor{_null};

2
glm/core/type_mat4x2.hpp
View File

@ -35,7 +35,7 @@
namespace glm{
namespace detail
{
template <typename T = float, precision P = defaultp>
template <typename T, precision P>
struct tmat4x2
{
enum ctor{_null};

2
glm/core/type_mat4x3.hpp
View File

@ -35,7 +35,7 @@
namespace glm{
namespace detail
{
template <typename T = float, precision P = defaultp>
template <typename T, precision P>
struct tmat4x3
{
enum ctor{_null};

2
glm/core/type_mat4x4.hpp
View File

@ -35,7 +35,7 @@
namespace glm{
namespace detail
{
template <typename T = float, precision P = defaultp>
template <typename T, precision P>
struct tmat4x4
{
enum ctor{_null};

16
glm/core/type_vec1.hpp
View File

@ -36,7 +36,7 @@
namespace glm{
namespace detail
{
template <typename T = float, precision P = defaultp>
template <typename T, precision P>
struct tvec1
{
//////////////////////////////////////
@ -83,7 +83,7 @@ namespace detail
//////////////////////////////////////
// Swizzle constructors
GLM_FUNC_DECL tvec1(tref1<T, P> const & r);
//////////////////////////////////////
// Conversion scalar constructors
@ -169,18 +169,6 @@ namespace detail
GLM_FUNC_DECL tvec1<T, P> & operator>>=(tvec1<U, P> const & v);
};
template <typename T, precision P>
struct tref1
{
GLM_FUNC_DECL tref1(T & x);
GLM_FUNC_DECL tref1(tref1<T, P> const & r);
GLM_FUNC_DECL tref1(tvec1<T, P> const & v);
GLM_FUNC_DECL tref1<T, P> & operator= (tref1<T, P> const & r);
GLM_FUNC_DECL tref1<T, P> & operator= (tvec1<T, P> const & v);
T& x;
};
GLM_DETAIL_IS_VECTOR(tvec1);
}//namespace detail

78
glm/core/type_vec1.inl
View File

@ -61,19 +61,13 @@ namespace detail
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1
(
tvec1<T, P> const & v
) :
GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1(tvec1<T, P> const & v) :
x(v.x)
{}
template <typename T, precision P>
template <precision Q>
GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1
(
tvec1<T, Q> const & v
) :
GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1(tvec1<T, Q> const & v) :
x(v.x)
{}
@ -81,31 +75,14 @@ namespace detail
// Explicit basic constructors
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1
(
ctor
)
GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1(ctor)
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1
(
T const & s
) :
GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1(T const & s) :
x(s)
{}
//////////////////////////////////////
// Swizzle constructors
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1
(
tref1<T, P> const & r
) :
x(r.x)
{}
//////////////////////////////////////
// Conversion scalar constructors
@ -842,52 +819,5 @@ namespace detail
~v.x);
}
//////////////////////////////////////
// tref definition
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref1<T, P>::tref1
(
T & x
) :
x(x)
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref1<T, P>::tref1
(
tref1<T, P> const & r
) :
x(r.x)
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref1<T, P>::tref1
(
tvec1<T, P> const & v
) :
x(v.x)
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref1<T, P> & tref1<T, P>::operator=
(
tref1<T, P> const & r
)
{
x = r.x;
return *this;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref1<T, P> & tref1<T, P>::operator=
(
tvec1<T, P> const & v
)
{
x = v.x;
return *this;
}
}//namespace detail
}//namespace glm

18
glm/core/type_vec2.hpp
View File

@ -36,7 +36,7 @@
namespace glm{
namespace detail
{
template <typename T = float, precision P = defaultp>
template <typename T, precision P>
struct tvec2
{
//////////////////////////////////////
@ -110,8 +110,6 @@ namespace detail
//////////////////////////////////////
// Swizzle constructors
GLM_FUNC_DECL tvec2(tref2<T, P> const & r);
# if(GLM_HAS_ANONYMOUS_UNION && defined(GLM_SWIZZLE))
template <int E0, int E1>
GLM_FUNC_DECL tvec2(_swizzle<2,T, P, tvec2<T, P>, E0, E1,-1,-2> const & that)
@ -207,20 +205,6 @@ namespace detail
GLM_FUNC_DECL tvec2<T, P> & operator>>=(tvec2<U, P> const & v);
};
template <typename T, precision P>
struct tref2
{
GLM_FUNC_DECL tref2(T & x, T & y);
GLM_FUNC_DECL tref2(tref2<T, P> const & r);
GLM_FUNC_DECL explicit tref2(tvec2<T, P> const & v);
GLM_FUNC_DECL tref2<T, P> & operator= (tref2<T, P> const & r);
GLM_FUNC_DECL tref2<T, P> & operator= (tvec2<T, P> const & v);
GLM_FUNC_DECL tvec2<T, P> operator() ();
T & x;
T & y;
};
GLM_DETAIL_IS_VECTOR(tvec2);
template <typename T, precision P>

90
glm/core/type_vec2.inl
View File

@ -62,20 +62,14 @@ namespace detail
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2
(
tvec2<T, P> const & v
) :
GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2(tvec2<T, P> const & v) :
x(v.x),
y(v.y)
{}
template <typename T, precision P>
template <precision Q>
GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2
(
tvec2<T, Q> const & v
) :
GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2(tvec2<T, Q> const & v) :
x(v.x),
y(v.y)
{}
@ -84,17 +78,11 @@ namespace detail
// Explicit basic constructors
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2
(
ctor
)
GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2(ctor)
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2
(
T const & s
) :
GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2(T const & s) :
x(s),
y(s)
{}
@ -109,18 +97,6 @@ namespace detail
y(s2)
{}
//////////////////////////////////////
// Swizzle constructors
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2
(
tref2<T, P> const & r
) :
x(r.x),
y(r.y)
{}
//////////////////////////////////////
// Conversion scalar constructors
@ -897,63 +873,5 @@ namespace detail
~v.y);
}
//////////////////////////////////////
// tref definition
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref2<T, P>::tref2
(
T & x,
T & y
) :
x(x),
y(y)
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref2<T, P>::tref2
(
tref2<T, P> const & r
) :
x(r.x),
y(r.y)
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref2<T, P>::tref2
(
tvec2<T, P> const & v
) :
x(v.x),
y(v.y)
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref2<T, P>& tref2<T, P>::operator=
(
tref2<T, P> const & r
)
{
x = r.x;
y = r.y;
return *this;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref2<T, P>& tref2<T, P>::operator=
(
tvec2<T, P> const & v
)
{
x = v.x;
y = v.y;
return *this;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec2<T, P> tref2<T, P>::operator() ()
{
return tvec2<T, P>(this->x, this->y);
}
}//namespace detail
}//namespace glm

25
glm/core/type_vec3.hpp
View File

@ -36,7 +36,7 @@
namespace glm{
namespace detail
{
template <typename T = float, precision P = defaultp>
template <typename T, precision P>
struct tvec3
{
//////////////////////////////////////
@ -142,14 +142,6 @@ namespace detail
//////////////////////////////////////
// Swizzle constructors
GLM_FUNC_DECL tvec3(tref3<T, P> const & r);
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec3(tref2<A, P> const & v, B const & s);
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec3(A const & s, tref2<B, P> const & v);
# if(GLM_HAS_ANONYMOUS_UNION && defined(GLM_SWIZZLE))
template <int E0, int E1, int E2>
GLM_FUNC_DECL tvec3(_swizzle<3, T, P, tvec3<T, P>, E0, E1, E2, -1> const & that)
@ -231,21 +223,6 @@ namespace detail
GLM_FUNC_DECL tvec3<T, P> & operator>>=(tvec3<U, P> const & v);
};
template <typename T, precision P>
struct tref3
{
GLM_FUNC_DECL tref3(T & x, T & y, T & z);
GLM_FUNC_DECL tref3(tref3<T, P> const & r);
GLM_FUNC_DECL explicit tref3(tvec3<T, P> const & v);
GLM_FUNC_DECL tref3<T, P> & operator= (tref3<T, P> const & r);
GLM_FUNC_DECL tref3<T, P> & operator= (tvec3<T, P> const & v);
GLM_FUNC_DECL tvec3<T, P> operator() ();
T & x;
T & y;
T & z;
};
GLM_DETAIL_IS_VECTOR(tvec3);
template <typename T, precision P>

117
glm/core/type_vec3.inl
View File

@ -63,10 +63,7 @@ namespace detail
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3
(
tvec3<T, P> const & v
) :
GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3(tvec3<T, P> const & v) :
x(v.x),
y(v.y),
z(v.z)
@ -74,10 +71,7 @@ namespace detail
template <typename T, precision P>
template <precision Q>
GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3
(
tvec3<T, Q> const & v
) :
GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3(tvec3<T, Q> const & v) :
x(v.x),
y(v.y),
z(v.z)
@ -87,17 +81,11 @@ namespace detail
// Explicit basic constructors
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3
(
ctor
)
GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3(ctor)
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3
(
T const & s
) :
GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3(T const & s) :
x(s),
y(s),
z(s)
@ -115,43 +103,6 @@ namespace detail
z(s2)
{}
//////////////////////////////////////
// Swizzle constructors
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3
(
tref3<T, P> const & r
) :
x(r.x),
y(r.y),
z(r.z)
{}
template <typename T, precision P>
template <typename A, typename B>
GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3
(
tref2<A, P> const & v,
B const & s
) :
x(static_cast<T>(v.x)),
y(static_cast<T>(v.y)),
z(static_cast<T>(s))
{}
template <typename T, precision P>
template <typename A, typename B>
GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3
(
A const & s,
tref2<B, P> const & v
) :
x(static_cast<T>(s)),
y(static_cast<T>(v.x)),
z(static_cast<T>(v.y))
{}
//////////////////////////////////////
// Conversion scalar constructors
@ -1003,65 +954,5 @@ namespace detail
~v.z);
}
//////////////////////////////////////
// tref definition
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref3<T, P>::tref3(T & x, T & y, T & z) :
x(x),
y(y),
z(z)
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref3<T, P>::tref3
(
tref3<T, P> const & r
) :
x(r.x),
y(r.y),
z(r.z)
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref3<T, P>::tref3
(
tvec3<T, P> const & v
) :
x(v.x),
y(v.y),
z(v.z)
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref3<T, P> & tref3<T, P>::operator=
(
tref3<T, P> const & r
)
{
x = r.x;
y = r.y;
z = r.z;
return *this;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref3<T, P> & tref3<T, P>::operator=
(
tvec3<T, P> const & v
)
{
x = v.x;
y = v.y;
z = v.z;
return *this;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec3<T, P> tref3<T, P>::operator() ()
{
return tvec3<T, P>(this->x, this->y, this->z);
}
}//namespace detail
}//namespace glm

45
glm/core/type_vec4.hpp
View File

@ -36,7 +36,7 @@
namespace glm{
namespace detail
{
template <typename T = float, precision P = defaultp>
template <typename T, precision P>
struct tvec4
{
//////////////////////////////////////
@ -154,33 +154,6 @@ namespace detail
//////////////////////////////////////
// Swizzle constructors
GLM_FUNC_DECL tvec4(tref4<T, P> const & r);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C>
GLM_FUNC_DECL explicit tvec4(tref2<A, P> const & v, B const & s1, C const & s2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C>
GLM_FUNC_DECL explicit tvec4(A const & s1, tref2<B, P> const & v, C const & s2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C>
GLM_FUNC_DECL explicit tvec4(A const & s1, B const & s2, tref2<C, P> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec4(tref3<A, P> const & v, B const & s);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec4(A const & s, tref3<B, P> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec4(tref2<A, P> const & v1, tref2<B, P> const & v2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec4(tvec2<A, P> const & v1, tref2<B, P> const & v2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
GLM_FUNC_DECL explicit tvec4(tref2<A, P> const & v1, tvec2<B, P> const & v2);
# if(GLM_HAS_ANONYMOUS_UNION && defined(GLM_SWIZZLE))
template <int E0, int E1, int E2, int E3>
GLM_FUNC_DECL tvec4(_swizzle<4, T, P, tvec4<T, P>, E0, E1, E2, E3> const & that)
@ -286,22 +259,6 @@ namespace detail
GLM_FUNC_DECL tvec4<T, P> & operator>>=(tvec4<U, P> const & v);
};
template <typename T, precision P>
struct tref4
{
GLM_FUNC_DECL tref4(T & x, T & y, T & z, T & w);
GLM_FUNC_DECL tref4(tref4<T, P> const & r);
GLM_FUNC_DECL explicit tref4(tvec4<T, P> const & v);
GLM_FUNC_DECL tref4<T, P> & operator= (tref4<T, P> const & r);
GLM_FUNC_DECL tref4<T, P> & operator= (tvec4<T, P> const & v);
GLM_FUNC_DECL tvec4<T, P> operator() ();
T & x;
T & y;
T & z;
T & w;
};
GLM_DETAIL_IS_VECTOR(tvec4);
template <typename T, precision P>

212
glm/core/type_vec4.inl
View File

@ -64,10 +64,7 @@ namespace detail
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
(
type const & v
) :
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(tvec4<T, P> const & v) :
x(v.x),
y(v.y),
z(v.z),
@ -76,10 +73,7 @@ namespace detail
template <typename T, precision P>
template <precision Q>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
(
tvec4<T, Q> const & v
) :
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(tvec4<T, Q> const & v) :
x(v.x),
y(v.y),
z(v.z),
@ -90,17 +84,11 @@ namespace detail
// Explicit basic constructors
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
(
ctor
)
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(ctor)
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
(
T const & s
) :
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(T const & s) :
x(s),
y(s),
z(s),
@ -121,127 +109,6 @@ namespace detail
w(s4)
{}
//////////////////////////////////////
// Swizzle constructors
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
(
tref4<T, P> const & r
) :
x(r.x),
y(r.y),
z(r.z),
w(r.w)
{}
template <typename T, precision P>
template <typename A, typename B, typename C>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
(
tref2<A, P> const & v,
B const & s1,
C const & s2
) :
x(static_cast<T>(v.x)),
y(static_cast<T>(v.y)),
z(static_cast<T>(s1)),
w(static_cast<T>(s2))
{}
template <typename T, precision P>
template <typename A, typename B, typename C>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
(
A const & s1,
tref2<B, P> const & v,
C const & s2
) :
x(static_cast<T>(s1)),
y(static_cast<T>(v.x)),
z(static_cast<T>(v.y)),
w(static_cast<T>(s2))
{}
template <typename T, precision P>
template <typename A, typename B, typename C>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
(
A const & s1,
B const & s2,
tref2<C, P> const & v
) :
x(static_cast<T>(s1)),
y(static_cast<T>(s2)),
z(static_cast<T>(v.x)),
w(static_cast<T>(v.y))
{}
template <typename T, precision P>
template <typename A, typename B>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
(
tref3<A, P> const & v,
B const & s
) :
x(static_cast<T>(v.x)),
y(static_cast<T>(v.y)),
z(static_cast<T>(v.z)),
w(static_cast<T>(s))
{}
template <typename T, precision P>
template <typename A, typename B>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
(
A const & s,
tref3<B, P> const & v
) :
x(static_cast<T>(s)),
y(static_cast<T>(v.x)),
z(static_cast<T>(v.y)),
w(static_cast<T>(v.z))
{}
template <typename T, precision P>
template <typename A, typename B>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
(
tref2<A, P> const & v1,
tref2<B, P> const & v2
) :
x(static_cast<T>(v1.x)),
y(static_cast<T>(v1.y)),
z(static_cast<T>(v2.x)),
w(static_cast<T>(v2.y))
{}
template <typename T, precision P>
template <typename A, typename B>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
(
tvec2<A, P> const & v1,
tref2<B, P> const & v2
) :
x(static_cast<T>(v1.x)),
y(static_cast<T>(v1.y)),
z(static_cast<T>(v2.x)),
w(static_cast<T>(v2.y))
{}
template <typename T, precision P>
template <typename A, typename B>
GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
(
tref2<A, P> const & v1,
tvec2<B, P> const & v2
) :
x(static_cast<T>(v1.x)),
y(static_cast<T>(v1.y)),
z(static_cast<T>(v2.x)),
w(static_cast<T>(v2.y))
{}
//////////////////////////////////////
// Conversion scalar constructors
@ -1199,76 +1066,5 @@ namespace detail
~v.w);
}
//////////////////////////////////////
// tref definition
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref4<T, P>::tref4
(
T & x,
T & y,
T & z,
T & w
) :
x(x),
y(y),
z(z),
w(w)
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref4<T, P>::tref4
(
tref4<T, P> const & r
) :
x(r.x),
y(r.y),
z(r.z),
w(r.w)
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref4<T, P>::tref4
(
tvec4<T, P> const & v
) :
x(v.x),
y(v.y),
z(v.z),
w(v.w)
{}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref4<T, P>& tref4<T, P>::operator=
(
tref4<T, P> const & r
)
{
x = r.x;
y = r.y;
z = r.z;
w = r.w;
return *this;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref4<T, P>& tref4<T, P>::operator=
(
tvec4<T, P> const & v
)
{
x = v.x;
y = v.y;
z = v.z;
w = v.w;
return *this;
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> tref4<T, P>::operator() ()
{
return tvec4<T, P>(this->x, this->y, this->z, this->w);
}
}//namespace detail
}//namespace glm