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

Removed vector type functions named swizzle

Browse Source
This commit is contained in:
Christophe Riccio 2013-09-15 14:45:29 +02:00
parent ca3927b61a
commit 5d66caa7da
8 changed files with 0 additions and 309 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
glm/core/type_vec1.hpp
View File

@ -167,15 +167,6 @@ namespace detail
GLM_FUNC_DECL tvec1<T, P> & operator>>=(U const & s); GLM_FUNC_DECL tvec1<T, P> & operator>>=(U const & s);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec1<T, P> & operator>>=(tvec1<U, P> const & v); GLM_FUNC_DECL tvec1<T, P> & operator>>=(tvec1<U, P> const & v);
//////////////////////////////////////
// Swizzle operators
GLM_FUNC_DECL T swizzle(comp X) const;
GLM_FUNC_DECL tvec2<T, P> swizzle(comp X, comp Y) const;
GLM_FUNC_DECL tvec3<T, P> swizzle(comp X, comp Y, comp Z) const;
GLM_FUNC_DECL tvec4<T, P> swizzle(comp X, comp Y, comp Z, comp W) const;
GLM_FUNC_DECL tref1<T, P> swizzle(comp X);
}; };
template <typename T, precision P> template <typename T, precision P>

61
glm/core/type_vec1.inl
View File

@ -460,67 +460,6 @@ namespace detail
return *this; return *this;
} }
//////////////////////////////////////
// Swizzle operators
template <typename T, precision P>
GLM_FUNC_QUALIFIER T tvec1<T, P>::swizzle(comp x) const
{
return (*this)[x];
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec2<T, P> tvec1<T, P>::swizzle
(
comp x,
comp y
) const
{
return tvec2<T, P>(
(*this)[x],
(*this)[y]);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec3<T, P> tvec1<T, P>::swizzle
(
comp x,
comp y,
comp z
) const
{
return tvec3<T, P>(
(*this)[x],
(*this)[y],
(*this)[z]);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> tvec1<T, P>::swizzle
(
comp x,
comp y,
comp z,
comp w
) const
{
return tvec4<T, P>(
(*this)[x],
(*this)[y],
(*this)[z],
(*this)[w]);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref1<T, P> tvec1<T, P>::swizzle
(
comp x
)
{
return tref1<T, P>(
(*this)[x]);
}
////////////////////////////////////// //////////////////////////////////////
// Binary arithmetic operators // Binary arithmetic operators

9
glm/core/type_vec2.hpp
View File

@ -204,15 +204,6 @@ namespace detail
GLM_FUNC_DECL tvec2<T, P> & operator>>=(U const & s); GLM_FUNC_DECL tvec2<T, P> & operator>>=(U const & s);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec2<T, P> & operator>>=(tvec2<U, P> const & v); GLM_FUNC_DECL tvec2<T, P> & operator>>=(tvec2<U, P> const & v);
//////////////////////////////////////
// Swizzle operators
GLM_FUNC_DECL T swizzle(comp X) const;
GLM_FUNC_DECL tvec2<T, P> swizzle(comp X, comp Y) const;
GLM_FUNC_DECL tvec3<T, P> swizzle(comp X, comp Y, comp Z) const;
GLM_FUNC_DECL tvec4<T, P> swizzle(comp X, comp Y, comp Z, comp W) const;
GLM_FUNC_DECL tref2<T, P> swizzle(comp X, comp Y);
}; };
template <typename T, precision P> template <typename T, precision P>

66
glm/core/type_vec2.inl
View File

@ -505,72 +505,6 @@ namespace detail
return *this; return *this;
} }
//////////////////////////////////////
// Swizzle operators
template <typename T, precision P>
GLM_FUNC_QUALIFIER T tvec2<T, P>::swizzle
(
comp x
) const
{
return (*this)[x];
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec2<T, P> tvec2<T, P>::swizzle
(
comp x,
comp y
) const
{
return tvec2<T, P>(
(*this)[x],
(*this)[y]);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec3<T, P> tvec2<T, P>::swizzle
(
comp x,
comp y,
comp z
) const
{
return tvec3<T, P>(
(*this)[x],
(*this)[y],
(*this)[z]);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> tvec2<T, P>::swizzle
(
comp x,
comp y,
comp z,
comp w
) const
{
return tvec4<T, P>(
(*this)[x],
(*this)[y],
(*this)[z],
(*this)[w]);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref2<T, P> tvec2<T, P>::swizzle
(
comp x,
comp y
)
{
return tref2<T, P>(
(*this)[x],
(*this)[y]);
}
////////////////////////////////////// //////////////////////////////////////
// Binary arithmetic operators // Binary arithmetic operators

10
glm/core/type_vec3.hpp
View File

@ -228,16 +228,6 @@ namespace detail
GLM_FUNC_DECL tvec3<T, P> & operator>>=(U const & s); GLM_FUNC_DECL tvec3<T, P> & operator>>=(U const & s);
template <typename U> template <typename U>
GLM_FUNC_DECL tvec3<T, P> & operator>>=(tvec3<U, P> const & v); GLM_FUNC_DECL tvec3<T, P> & operator>>=(tvec3<U, P> const & v);
//////////////////////////////////////
// Swizzle operators
GLM_FUNC_DECL T swizzle(comp X) const;
GLM_FUNC_DECL tvec2<T, P> swizzle(comp X, comp Y) const;
GLM_FUNC_DECL tvec3<T, P> swizzle(comp X, comp Y, comp Z) const;
GLM_FUNC_DECL tvec4<T, P> swizzle(comp X, comp Y, comp Z, comp W) const;
GLM_FUNC_DECL tref2<T, P> swizzle(comp X, comp Y);
GLM_FUNC_DECL tref3<T, P> swizzle(comp X, comp Y, comp Z);
}; };
template <typename T, precision P> template <typename T, precision P>

80
glm/core/type_vec3.inl
View File

@ -579,86 +579,6 @@ namespace detail
return *this; return *this;
} }
//////////////////////////////////////
// Swizzle operators
template <typename T, precision P>
GLM_FUNC_QUALIFIER T tvec3<T, P>::swizzle
(
comp x
) const
{
return (*this)[x];
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec2<T, P> tvec3<T, P>::swizzle
(
comp x,
comp y
) const
{
return tvec2<T, P>(
(*this)[x],
(*this)[y]);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec3<T, P> tvec3<T, P>::swizzle
(
comp x,
comp y,
comp z
) const
{
return tvec3<T, P>(
(*this)[x],
(*this)[y],
(*this)[z]);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> tvec3<T, P>::swizzle
(
comp x,
comp y,
comp z,
comp w
) const
{
return tvec4<T, P>(
(*this)[x],
(*this)[y],
(*this)[z],
(*this)[w]);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref2<T, P> tvec3<T, P>::swizzle
(
comp x,
comp y
)
{
return tref2<T, P>(
(*this)[x],
(*this)[y]);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref3<T, P> tvec3<T, P>::swizzle
(
comp x,
comp y,
comp z
)
{
return tref3<T, P>(
(*this)[x],
(*this)[y],
(*this)[z]);
}
////////////////////////////////////// //////////////////////////////////////
// Binary arithmetic operators // Binary arithmetic operators

11
glm/core/type_vec4.hpp
View File

@ -283,17 +283,6 @@ namespace detail
GLM_FUNC_DECL tvec4<T, P> & operator>>=(U const & s); GLM_FUNC_DECL tvec4<T, P> & operator>>=(U const & s);
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);
//////////////////////////////////////
// Swizzle operators
GLM_FUNC_DECL T swizzle(comp X) const;
GLM_FUNC_DECL tvec2<T, P> swizzle(comp X, comp Y) const;
GLM_FUNC_DECL tvec3<T, P> swizzle(comp X, comp Y, comp Z) const;
GLM_FUNC_DECL tvec4<T, P> swizzle(comp X, comp Y, comp Z, comp W) const;
GLM_FUNC_DECL tref2<T, P> swizzle(comp X, comp Y);
GLM_FUNC_DECL tref3<T, P> swizzle(comp X, comp Y, comp Z);
GLM_FUNC_DECL tref4<T, P> swizzle(comp X, comp Y, comp Z, comp W);
}; };
template <typename T, precision P> template <typename T, precision P>

63
glm/core/type_vec4.inl
View File

@ -720,69 +720,6 @@ namespace detail
return *this; return *this;
} }
//////////////////////////////////////
// Swizzle operators
template <typename T, precision P>
GLM_FUNC_QUALIFIER T tvec4<T, P>::swizzle(comp x) const
{
return (*this)[x];
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec2<T, P> tvec4<T, P>::swizzle(comp x, comp y) const
{
return tvec2<T, P>(
(*this)[x],
(*this)[y]);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec3<T, P> tvec4<T, P>::swizzle(comp x, comp y, comp z) const
{
return tvec3<T, P>(
(*this)[x],
(*this)[y],
(*this)[z]);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tvec4<T, P> tvec4<T, P>::swizzle(comp x, comp y, comp z, comp w) const
{
return tvec4<T, P>(
(*this)[x],
(*this)[y],
(*this)[z],
(*this)[w]);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref2<T, P> tvec4<T, P>::swizzle(comp x, comp y)
{
return tref2<T, P>(
(*this)[x],
(*this)[y]);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref3<T, P> tvec4<T, P>::swizzle(comp x, comp y, comp z)
{
return tref3<T, P>(
(*this)[x],
(*this)[y],
(*this)[z]);
}
template <typename T, precision P>
GLM_FUNC_QUALIFIER tref4<T, P> tvec4<T, P>::swizzle(comp x, comp y, comp z, comp w)
{
return tref4<T, P>(
(*this)[x],
(*this)[y],
(*this)[z],
(*this)[w]);
}
////////////////////////////////////// //////////////////////////////////////
// Binary arithmetic operators // Binary arithmetic operators