Removed GTC_swizzle
This commit is contained in:
Christophe Riccio
parent
0464c836cb
commit
8e955736ac
@ -1,381 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
/// OpenGL Mathematics (glm.g-truc.net)
|
||||
///
|
||||
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
/// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
/// of this software and associated documentation files (the "Software"), to deal
|
||||
/// in the Software without restriction, including without limitation the rights
|
||||
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
/// copies of the Software, and to permit persons to whom the Software is
|
||||
/// furnished to do so, subject to the following conditions:
|
||||
///
|
||||
/// The above copyright notice and this permission notice shall be included in
|
||||
/// all copies or substantial portions of the Software.
|
||||
///
|
||||
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
/// THE SOFTWARE.
|
||||
///
|
||||
/// @ref gtc_swizzle
|
||||
/// @file glm/gtc/swizzle.hpp
|
||||
/// @date 2010-02-20 / 2011-06-05
|
||||
/// @author Christophe Riccio
|
||||
///
|
||||
/// @see core (dependence)
|
||||
///
|
||||
/// @defgroup gtc_swizzle GLM_GTC_swizzle
|
||||
/// @ingroup gtc
|
||||
///
|
||||
/// @brief Provide functions to emulate GLSL swizzle operator fonctionalities.
|
||||
///
|
||||
/// <glm/gtc/swizzle.hpp> need to be included to use these functionalities.
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLM_GTC_swizzle
|
||||
#define GLM_GTC_swizzle GLM_VERSION
|
||||
|
||||
// Dependency:
|
||||
#include "../glm.hpp"
|
||||
#include "../gtc/type_precision.hpp"
|
||||
|
||||
#if(defined(GLM_MESSAGES) && !defined(glm_ext))
|
||||
# pragma message("GLM: GLM_GTC_swizzle extension included")
|
||||
#endif
|
||||
|
||||
namespace glm
|
||||
{
|
||||
/// @addtogroup gtc_swizzle
|
||||
/// @{
|
||||
|
||||
template <typename T, precision P, template <typename, precision> class vecType>
|
||||
T const & swizzle(
|
||||
vecType<T, P> const & v,
|
||||
comp x);
|
||||
|
||||
template <typename T, precision P, template <typename, precision> class vecType>
|
||||
detail::tvec2<T, P> const & swizzle(
|
||||
vecType<T, P> const & v,
|
||||
comp x, comp y);
|
||||
|
||||
template <typename T, precision P, template <typename, precision> class vecType>
|
||||
detail::tvec3<T, P> const & swizzle(
|
||||
vecType<T, P> const & v,
|
||||
comp x, comp y, comp z);
|
||||
|
||||
template <typename T, precision P, template <typename, precision> class vecType>
|
||||
detail::tvec4<T, P> const & swizzle(
|
||||
vecType<T, P> const & v,
|
||||
comp x, comp y, comp z, comp w);
|
||||
|
||||
template <typename T, precision P, template <typename, precision> class vecType>
|
||||
T & swizzle(
|
||||
vecType<T, P> & v,
|
||||
comp x);
|
||||
|
||||
template <typename T, precision P, template <typename, precision> class vecType>
|
||||
detail::tref2<T, P> swizzle(
|
||||
vecType<T, P> & v,
|
||||
comp x, comp y);
|
||||
|
||||
template <typename T, precision P, template <typename, precision> class vecType>
|
||||
detail::tref3<T, P> swizzle(
|
||||
vecType<T, P> & v,
|
||||
comp x, comp y, comp z);
|
||||
|
||||
template <typename T, precision P, template <typename, precision> class vecType>
|
||||
detail::tref4<T, P> swizzle(
|
||||
vecType<T, P> & v,
|
||||
comp x, comp y, comp z, comp w);
|
||||
|
||||
# define static_swizzle1_const(TYPE, SIZE) \
|
||||
template <comp x> \
|
||||
GLM_FUNC_QUALIFIER TYPE swizzle(detail::tvec##SIZE<TYPE, defaultp> const & v) \
|
||||
{return v[x];}
|
||||
|
||||
# define static_swizzle1_ref(TYPE, SIZE) \
|
||||
template <comp x> \
|
||||
GLM_FUNC_QUALIFIER TYPE& swizzle(detail::tvec##SIZE<TYPE, defaultp> & v) \
|
||||
{return v[x];}
|
||||
|
||||
static_swizzle1_ref(detail::float16, 2)
|
||||
static_swizzle1_ref(detail::float16, 3)
|
||||
static_swizzle1_ref(detail::float16, 4)
|
||||
static_swizzle1_ref(detail::float32, 2)
|
||||
static_swizzle1_ref(detail::float32, 3)
|
||||
static_swizzle1_ref(detail::float32, 4)
|
||||
static_swizzle1_ref(detail::float64, 2)
|
||||
static_swizzle1_ref(detail::float64, 3)
|
||||
static_swizzle1_ref(detail::float64, 4)
|
||||
|
||||
static_swizzle1_ref(detail::int8, 2)
|
||||
static_swizzle1_ref(detail::int8, 3)
|
||||
static_swizzle1_ref(detail::int8, 4)
|
||||
static_swizzle1_ref(detail::int16, 2)
|
||||
static_swizzle1_ref(detail::int16, 3)
|
||||
static_swizzle1_ref(detail::int16, 4)
|
||||
static_swizzle1_ref(detail::int32, 2)
|
||||
static_swizzle1_ref(detail::int32, 3)
|
||||
static_swizzle1_ref(detail::int32, 4)
|
||||
static_swizzle1_ref(detail::int64, 2)
|
||||
static_swizzle1_ref(detail::int64, 3)
|
||||
static_swizzle1_ref(detail::int64, 4)
|
||||
|
||||
static_swizzle1_ref(detail::uint8, 2)
|
||||
static_swizzle1_ref(detail::uint8, 3)
|
||||
static_swizzle1_ref(detail::uint8, 4)
|
||||
static_swizzle1_ref(detail::uint16, 2)
|
||||
static_swizzle1_ref(detail::uint16, 3)
|
||||
static_swizzle1_ref(detail::uint16, 4)
|
||||
static_swizzle1_ref(detail::uint32, 2)
|
||||
static_swizzle1_ref(detail::uint32, 3)
|
||||
static_swizzle1_ref(detail::uint32, 4)
|
||||
static_swizzle1_ref(detail::uint64, 2)
|
||||
static_swizzle1_ref(detail::uint64, 3)
|
||||
static_swizzle1_ref(detail::uint64, 4)
|
||||
/*
|
||||
# define static_swizzle2_const(TYPE) \
|
||||
template <comp x, comp y> \
|
||||
GLM_FUNC_QUALIFIER TYPE swizzle(TYPE const & v) \
|
||||
{return TYPE(v[x], v[y]);}
|
||||
|
||||
# define static_swizzle3_const(TYPE) \
|
||||
template <comp x, comp y, comp z> \
|
||||
GLM_FUNC_QUALIFIER TYPE swizzle(TYPE const & v) \
|
||||
{return TYPE(v[x], v[y], v[z]);}
|
||||
|
||||
# define static_swizzle4_const(TYPE) \
|
||||
template <comp x, comp y, comp z, comp w> \
|
||||
GLM_FUNC_QUALIFIER TYPE swizzle(TYPE const & v) \
|
||||
{return TYPE(v[x], v[y], v[z], v[w]);}
|
||||
*/
|
||||
|
||||
# define static_swizzle2_const(TYPE, SIZE) \
|
||||
template <comp x, comp y> \
|
||||
GLM_FUNC_QUALIFIER detail::tvec2<TYPE, defaultp> swizzle( \
|
||||
detail::tvec##SIZE<TYPE, defaultp> const & v) \
|
||||
{return detail::tvec2<TYPE, defaultp>(v[x], v[y]);}
|
||||
|
||||
# define static_swizzle3_const(TYPE, SIZE) \
|
||||
template <comp x, comp y, comp z> \
|
||||
GLM_FUNC_QUALIFIER detail::tvec3<TYPE, defaultp> swizzle( \
|
||||
detail::tvec##SIZE<TYPE, defaultp> const & v) \
|
||||
{return detail::tvec3<TYPE, defaultp>(v[x], v[y], v[z]);}
|
||||
|
||||
# define static_swizzle4_const(TYPE, SIZE) \
|
||||
template <comp x, comp y, comp z, comp w> \
|
||||
GLM_FUNC_QUALIFIER detail::tvec4<TYPE, defaultp> swizzle( \
|
||||
detail::tvec##SIZE<TYPE, defaultp> const & v) \
|
||||
{return detail::tvec4<TYPE, defaultp>(v[x], v[y], v[z], v[w]);}
|
||||
|
||||
|
||||
static_swizzle2_const(glm::f16, 2)
|
||||
static_swizzle2_const(glm::f16, 3)
|
||||
static_swizzle2_const(glm::f16, 4)
|
||||
static_swizzle2_const(glm::f32, 2)
|
||||
static_swizzle2_const(glm::f32, 3)
|
||||
static_swizzle2_const(glm::f32, 4)
|
||||
static_swizzle2_const(glm::f64, 2)
|
||||
static_swizzle2_const(glm::f64, 3)
|
||||
static_swizzle2_const(glm::f64, 4)
|
||||
|
||||
static_swizzle2_const(glm::i8, 2)
|
||||
static_swizzle2_const(glm::i8, 3)
|
||||
static_swizzle2_const(glm::i8, 4)
|
||||
static_swizzle2_const(glm::i16, 2)
|
||||
static_swizzle2_const(glm::i16, 3)
|
||||
static_swizzle2_const(glm::i16, 4)
|
||||
static_swizzle2_const(glm::i32, 2)
|
||||
static_swizzle2_const(glm::i32, 3)
|
||||
static_swizzle2_const(glm::i32, 4)
|
||||
static_swizzle2_const(glm::i64, 2)
|
||||
static_swizzle2_const(glm::i64, 3)
|
||||
static_swizzle2_const(glm::i64, 4)
|
||||
|
||||
static_swizzle2_const(glm::u8, 2)
|
||||
static_swizzle2_const(glm::u8, 3)
|
||||
static_swizzle2_const(glm::u8, 4)
|
||||
static_swizzle2_const(glm::u16, 2)
|
||||
static_swizzle2_const(glm::u16, 3)
|
||||
static_swizzle2_const(glm::u16, 4)
|
||||
static_swizzle2_const(glm::u32, 2)
|
||||
static_swizzle2_const(glm::u32, 3)
|
||||
static_swizzle2_const(glm::u32, 4)
|
||||
static_swizzle2_const(glm::u64, 2)
|
||||
static_swizzle2_const(glm::u64, 3)
|
||||
static_swizzle2_const(glm::u64, 4)
|
||||
|
||||
static_swizzle3_const(glm::f16, 2)
|
||||
static_swizzle3_const(glm::f16, 3)
|
||||
static_swizzle3_const(glm::f16, 4)
|
||||
static_swizzle3_const(glm::f32, 2)
|
||||
static_swizzle3_const(glm::f32, 3)
|
||||
static_swizzle3_const(glm::f32, 4)
|
||||
static_swizzle3_const(glm::f64, 2)
|
||||
static_swizzle3_const(glm::f64, 3)
|
||||
static_swizzle3_const(glm::f64, 4)
|
||||
|
||||
static_swizzle3_const(glm::i8, 2)
|
||||
static_swizzle3_const(glm::i8, 3)
|
||||
static_swizzle3_const(glm::i8, 4)
|
||||
static_swizzle3_const(glm::i16, 2)
|
||||
static_swizzle3_const(glm::i16, 3)
|
||||
static_swizzle3_const(glm::i16, 4)
|
||||
static_swizzle3_const(glm::i32, 2)
|
||||
static_swizzle3_const(glm::i32, 3)
|
||||
static_swizzle3_const(glm::i32, 4)
|
||||
static_swizzle3_const(glm::i64, 2)
|
||||
static_swizzle3_const(glm::i64, 3)
|
||||
static_swizzle3_const(glm::i64, 4)
|
||||
|
||||
static_swizzle3_const(glm::u8, 2)
|
||||
static_swizzle3_const(glm::u8, 3)
|
||||
static_swizzle3_const(glm::u8, 4)
|
||||
static_swizzle3_const(glm::u16, 2)
|
||||
static_swizzle3_const(glm::u16, 3)
|
||||
static_swizzle3_const(glm::u16, 4)
|
||||
static_swizzle3_const(glm::u32, 2)
|
||||
static_swizzle3_const(glm::u32, 3)
|
||||
static_swizzle3_const(glm::u32, 4)
|
||||
static_swizzle3_const(glm::u64, 2)
|
||||
static_swizzle3_const(glm::u64, 3)
|
||||
static_swizzle3_const(glm::u64, 4)
|
||||
|
||||
static_swizzle4_const(glm::f16, 2)
|
||||
static_swizzle4_const(glm::f16, 3)
|
||||
static_swizzle4_const(glm::f16, 4)
|
||||
static_swizzle4_const(glm::f32, 2)
|
||||
static_swizzle4_const(glm::f32, 3)
|
||||
static_swizzle4_const(glm::f32, 4)
|
||||
static_swizzle4_const(glm::f64, 2)
|
||||
static_swizzle4_const(glm::f64, 3)
|
||||
static_swizzle4_const(glm::f64, 4)
|
||||
|
||||
static_swizzle4_const(glm::i8, 2)
|
||||
static_swizzle4_const(glm::i8, 3)
|
||||
static_swizzle4_const(glm::i8, 4)
|
||||
static_swizzle4_const(glm::i16, 2)
|
||||
static_swizzle4_const(glm::i16, 3)
|
||||
static_swizzle4_const(glm::i16, 4)
|
||||
static_swizzle4_const(glm::i32, 2)
|
||||
static_swizzle4_const(glm::i32, 3)
|
||||
static_swizzle4_const(glm::i32, 4)
|
||||
static_swizzle4_const(glm::i64, 2)
|
||||
static_swizzle4_const(glm::i64, 3)
|
||||
static_swizzle4_const(glm::i64, 4)
|
||||
|
||||
static_swizzle4_const(glm::u8, 2)
|
||||
static_swizzle4_const(glm::u8, 3)
|
||||
static_swizzle4_const(glm::u8, 4)
|
||||
static_swizzle4_const(glm::u16, 2)
|
||||
static_swizzle4_const(glm::u16, 3)
|
||||
static_swizzle4_const(glm::u16, 4)
|
||||
static_swizzle4_const(glm::u32, 2)
|
||||
static_swizzle4_const(glm::u32, 3)
|
||||
static_swizzle4_const(glm::u32, 4)
|
||||
static_swizzle4_const(glm::u64, 2)
|
||||
static_swizzle4_const(glm::u64, 3)
|
||||
static_swizzle4_const(glm::u64, 4)
|
||||
|
||||
# define static_swizzle2_ref(TYPE, SIZE) \
|
||||
template <glm::comp x, glm::comp y> \
|
||||
GLM_FUNC_QUALIFIER glm::detail::tref2<TYPE, defaultp> swizzle( \
|
||||
detail::tvec##SIZE<TYPE, defaultp> & v) \
|
||||
{return glm::detail::tref2<TYPE, defaultp>(v[x], v[y]);}
|
||||
|
||||
# define static_swizzle3_ref(TYPE, SIZE) \
|
||||
template <glm::comp x, glm::comp y, glm::comp z> \
|
||||
GLM_FUNC_QUALIFIER glm::detail::tref3<TYPE, defaultp> swizzle( \
|
||||
detail::tvec##SIZE<TYPE, defaultp> & v) \
|
||||
{return glm::detail::tref3<TYPE, defaultp>(v[x], v[y], v[z]);}
|
||||
|
||||
# define static_swizzle4_ref(TYPE, SIZE) \
|
||||
template <glm::comp x, glm::comp y, glm::comp z, glm::comp w> \
|
||||
GLM_FUNC_QUALIFIER glm::detail::tref4<TYPE, defaultp> swizzle( \
|
||||
detail::tvec##SIZE<TYPE, defaultp> & v) \
|
||||
{return glm::detail::tref4<TYPE, defaultp>(v[x], v[y], v[z], v[w]);}
|
||||
|
||||
static_swizzle2_ref(glm::f16, 2)
|
||||
static_swizzle2_ref(glm::f16, 3)
|
||||
static_swizzle2_ref(glm::f16, 4)
|
||||
static_swizzle2_ref(glm::f32, 2)
|
||||
static_swizzle2_ref(glm::f32, 3)
|
||||
static_swizzle2_ref(glm::f32, 4)
|
||||
static_swizzle2_ref(glm::f64, 2)
|
||||
static_swizzle2_ref(glm::f64, 3)
|
||||
static_swizzle2_ref(glm::f64, 4)
|
||||
|
||||
static_swizzle2_ref(glm::i8, 2)
|
||||
static_swizzle2_ref(glm::i8, 3)
|
||||
static_swizzle2_ref(glm::i8, 4)
|
||||
static_swizzle2_ref(glm::i16, 2)
|
||||
static_swizzle2_ref(glm::i16, 3)
|
||||
static_swizzle2_ref(glm::i16, 4)
|
||||
static_swizzle2_ref(glm::i32, 2)
|
||||
static_swizzle2_ref(glm::i32, 3)
|
||||
static_swizzle2_ref(glm::i32, 4)
|
||||
static_swizzle2_ref(glm::i64, 2)
|
||||
static_swizzle2_ref(glm::i64, 3)
|
||||
static_swizzle2_ref(glm::i64, 4)
|
||||
|
||||
static_swizzle2_ref(glm::u8, 2)
|
||||
static_swizzle2_ref(glm::u8, 3)
|
||||
static_swizzle2_ref(glm::u8, 4)
|
||||
static_swizzle2_ref(glm::u16, 2)
|
||||
static_swizzle2_ref(glm::u16, 3)
|
||||
static_swizzle2_ref(glm::u16, 4)
|
||||
static_swizzle2_ref(glm::u32, 2)
|
||||
static_swizzle2_ref(glm::u32, 3)
|
||||
static_swizzle2_ref(glm::u32, 4)
|
||||
static_swizzle2_ref(glm::u64, 2)
|
||||
static_swizzle2_ref(glm::u64, 3)
|
||||
static_swizzle2_ref(glm::u64, 4)
|
||||
|
||||
static_swizzle3_ref(glm::f16, 3)
|
||||
static_swizzle3_ref(glm::f16, 4)
|
||||
static_swizzle3_ref(glm::f32, 3)
|
||||
static_swizzle3_ref(glm::f32, 4)
|
||||
static_swizzle3_ref(glm::f64, 3)
|
||||
static_swizzle3_ref(glm::f64, 4)
|
||||
|
||||
static_swizzle3_ref(glm::i8, 3)
|
||||
static_swizzle3_ref(glm::i8, 4)
|
||||
static_swizzle3_ref(glm::i16, 3)
|
||||
static_swizzle3_ref(glm::i16, 4)
|
||||
static_swizzle3_ref(glm::i32, 3)
|
||||
static_swizzle3_ref(glm::i32, 4)
|
||||
static_swizzle3_ref(glm::i64, 3)
|
||||
static_swizzle3_ref(glm::i64, 4)
|
||||
|
||||
static_swizzle3_ref(glm::u8, 3)
|
||||
static_swizzle3_ref(glm::u8, 4)
|
||||
static_swizzle3_ref(glm::u16, 3)
|
||||
static_swizzle3_ref(glm::u16, 4)
|
||||
static_swizzle3_ref(glm::u32, 3)
|
||||
static_swizzle3_ref(glm::u32, 4)
|
||||
static_swizzle3_ref(glm::u64, 3)
|
||||
static_swizzle3_ref(glm::u64, 4)
|
||||
|
||||
static_swizzle4_ref(glm::f16, 4)
|
||||
static_swizzle4_ref(glm::f32, 4)
|
||||
static_swizzle4_ref(glm::f64, 4)
|
||||
|
||||
static_swizzle4_ref(glm::i8, 4)
|
||||
static_swizzle4_ref(glm::i16, 4)
|
||||
static_swizzle4_ref(glm::i32, 4)
|
||||
static_swizzle4_ref(glm::i64, 4)
|
||||
|
||||
static_swizzle4_ref(glm::u8, 4)
|
||||
static_swizzle4_ref(glm::u16, 4)
|
||||
static_swizzle4_ref(glm::u32, 4)
|
||||
static_swizzle4_ref(glm::u64, 4)
|
||||
|
||||
/// @}
|
||||
}//namespace glm
|
||||
|
||||
#include "swizzle.inl"
|
||||
|
||||
#endif//GLM_GTC_swizzle
|
||||
@ -1,116 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
/// OpenGL Mathematics (glm.g-truc.net)
|
||||
///
|
||||
/// Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
/// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
/// of this software and associated documentation files (the "Software"), to deal
|
||||
/// in the Software without restriction, including without limitation the rights
|
||||
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
/// copies of the Software, and to permit persons to whom the Software is
|
||||
/// furnished to do so, subject to the following conditions:
|
||||
///
|
||||
/// The above copyright notice and this permission notice shall be included in
|
||||
/// all copies or substantial portions of the Software.
|
||||
///
|
||||
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
/// THE SOFTWARE.
|
||||
///
|
||||
/// @ref gtc_swizzle
|
||||
/// @file glm/gtc/swizzle.inl
|
||||
/// @date 2011-01-15 / 2011-06-15
|
||||
/// @author Christophe Riccio
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
namespace glm
|
||||
{
|
||||
template <typename T, precision P, template <typename, precision> class vecType>
|
||||
GLM_FUNC_QUALIFIER T swizzle
|
||||
(
|
||||
vecType<T, P> const & v,
|
||||
comp x
|
||||
)
|
||||
{
|
||||
assert(int(x) < int(vecType<T, P>::value_size));
|
||||
return v[x];
|
||||
}
|
||||
|
||||
template <typename T, precision P, template <typename, precision> class vecType>
|
||||
GLM_FUNC_QUALIFIER detail::tvec2<T, P> swizzle
|
||||
(
|
||||
vecType<T, P> const & v,
|
||||
comp x, comp y
|
||||
)
|
||||
{
|
||||
return detail::tvec2<T, P>(
|
||||
v[x],
|
||||
v[y]);
|
||||
}
|
||||
|
||||
template <typename T, precision P, template <typename, precision> class vecType>
|
||||
GLM_FUNC_QUALIFIER detail::tvec3<T, P> swizzle
|
||||
(
|
||||
vecType<T, P> const & v,
|
||||
comp x, comp y, comp z
|
||||
)
|
||||
{
|
||||
return detail::tvec3<T, P>(
|
||||
v[x],
|
||||
v[y],
|
||||
v[z]);
|
||||
}
|
||||
|
||||
template <typename T, precision P, template <typename, precision> class vecType>
|
||||
GLM_FUNC_QUALIFIER detail::tvec4<T, P> swizzle
|
||||
(
|
||||
vecType<T, P> const & v,
|
||||
comp x, comp y, comp z, comp w
|
||||
)
|
||||
{
|
||||
return detail::tvec4<T, P>(v[x], v[y], v[z], v[w]);
|
||||
}
|
||||
|
||||
template <typename T, precision P>
|
||||
GLM_FUNC_QUALIFIER T& swizzle
|
||||
(
|
||||
detail::tvec4<T, P> & v,
|
||||
comp x
|
||||
)
|
||||
{
|
||||
return v[x];
|
||||
}
|
||||
|
||||
template <typename T, precision P>
|
||||
GLM_FUNC_QUALIFIER detail::tref2<T, P> swizzle
|
||||
(
|
||||
detail::tvec4<T, P> & v,
|
||||
comp x, comp y
|
||||
)
|
||||
{
|
||||
return detail::tref2<T, P>(v[x], v[y]);
|
||||
}
|
||||
|
||||
template <typename T, precision P>
|
||||
GLM_FUNC_QUALIFIER detail::tref3<T, P> swizzle
|
||||
(
|
||||
detail::tvec4<T, P> & v,
|
||||
comp x, comp y, comp z
|
||||
)
|
||||
{
|
||||
return detail::tref3<T, P>(v[x], v[y], v[z]);
|
||||
}
|
||||
|
||||
template <typename T, precision P>
|
||||
GLM_FUNC_QUALIFIER detail::tref4<T, P> swizzle
|
||||
(
|
||||
detail::tvec4<T, P> & v,
|
||||
comp x, comp y, comp z, comp w
|
||||
)
|
||||
{
|
||||
return detail::tref4<T, P>(v[x], v[y], v[z], v[w]);
|
||||
}
|
||||
}//namespace glm
|
||||
@ -10,7 +10,6 @@ glmCreateTestGTC(gtc_packing)
|
||||
glmCreateTestGTC(gtc_quaternion)
|
||||
glmCreateTestGTC(gtc_random)
|
||||
glmCreateTestGTC(gtc_reciprocal)
|
||||
glmCreateTestGTC(gtc_swizzle)
|
||||
glmCreateTestGTC(gtc_type_precision)
|
||||
glmCreateTestGTC(gtc_type_ptr)
|
||||
glmCreateTestGTC(gtc_ulp)
|
||||
|
||||
@ -1,203 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2010-09-16
|
||||
// Updated : 2010-09-16
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtc/swizzle.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp>
|
||||
#include <glm/gtc/swizzle.hpp>
|
||||
|
||||
int test_swizzle_vec4_ref_dynamic()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
{
|
||||
glm::ivec4 A(0, 1, 2, 3);
|
||||
glm::ivec4 B(2, 1, 0, 3);
|
||||
glm::swizzle(A, glm::Z, glm::Y, glm::X, glm::W) = B;
|
||||
Error += (A.z == B.x && A.y == B.y && A.x == B.z && A.w == B.w) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::ivec4 A(0, 1, 2, 3);
|
||||
glm::ivec3 B(2, 1, 0);
|
||||
glm::swizzle(A, glm::Z, glm::Y, glm::X) = B;
|
||||
Error += (A.z == B.x && A.y == B.y && A.x == B.z) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::ivec4 A(0, 1, 2, 3);
|
||||
glm::ivec2 B(2, 1);
|
||||
glm::swizzle(A, glm::Z, glm::Y) = B;
|
||||
Error += (A.z == B.x && A.y == B.y) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::ivec4 A(0, 1, 2, 3);
|
||||
int B(2);
|
||||
glm::swizzle(A, glm::Z) = B;
|
||||
Error += (A.z == B) ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_swizzle_vec4_ref_static()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
{
|
||||
glm::ivec4 A(0, 1, 2, 3);
|
||||
glm::ivec4 B(2, 1, 0, 3);
|
||||
glm::swizzle<glm::Z, glm::Y, glm::X, glm::W>(A) = B;
|
||||
Error += (A.z == B.x && A.y == B.y && A.x == B.z && A.w == B.w) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::ivec4 A(0, 1, 2, 3);
|
||||
glm::ivec3 B(2, 1, 0);
|
||||
glm::swizzle<glm::Z, glm::Y, glm::X>(A) = B;
|
||||
Error += (A.z == B.x && A.y == B.y && A.x == B.z) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::ivec4 A(0, 1, 2, 3);
|
||||
glm::ivec2 B(2, 1);
|
||||
glm::swizzle<glm::Z, glm::Y>(A) = B;
|
||||
Error += (A.z == B.x && A.y == B.y) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::ivec4 A(0, 1, 2, 3);
|
||||
int B(2);
|
||||
glm::swizzle<glm::Z>(A) = B;
|
||||
Error += (A.z == B) ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_swizzle_vec4_const_dynamic()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::ivec4 A(0, 1, 2, 3);
|
||||
glm::ivec4 B = glm::swizzle(A, glm::B, glm::G, glm::R, glm::A);
|
||||
Error += (glm::all(glm::equal(glm::ivec4(2, 1, 0, 3), B))) ? 0 : 1;
|
||||
|
||||
glm::ivec3 C = glm::swizzle(A, glm::W, glm::Y, glm::Z);
|
||||
Error += (glm::all(glm::equal(glm::ivec3(3, 1, 2), C))) ? 0 : 1;
|
||||
|
||||
glm::ivec2 D = glm::swizzle(A, glm::W, glm::X);
|
||||
Error += (glm::all(glm::equal(glm::ivec2(3, 0), D))) ? 0 : 1;
|
||||
|
||||
int E = glm::swizzle(A, glm::Q);
|
||||
Error += (E == 3) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_swizzle_vec4_const_static()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::ivec4 A(0, 1, 2, 3);
|
||||
|
||||
glm::ivec4 B = glm::swizzle<glm::B, glm::G, glm::R, glm::A>(A);
|
||||
Error += (glm::all(glm::equal(glm::ivec4(2, 1, 0, 3), B))) ? 0 : 1;
|
||||
|
||||
glm::ivec3 C = glm::swizzle<glm::W, glm::Y, glm::Z>(A);
|
||||
Error += (glm::all(glm::equal(glm::ivec3(3, 1, 2), C))) ? 0 : 1;
|
||||
|
||||
glm::ivec2 D = glm::swizzle<glm::W, glm::X>(A);
|
||||
Error += (glm::all(glm::equal(glm::ivec2(3, 0), D))) ? 0 : 1;
|
||||
|
||||
int E = glm::swizzle<glm::Q>(A);
|
||||
Error += (E == 3) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_swizzle_vec3_partial()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::ivec3 A(0, 1, 2);
|
||||
|
||||
{
|
||||
glm::ivec3 B(A.swizzle(glm::R, glm::G, glm::B));
|
||||
Error += (A == B) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::ivec3 B(A.swizzle(glm::R, glm::G), 2);
|
||||
Error += (A == B) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::ivec3 B(0, A.swizzle(glm::G, glm::B));
|
||||
Error += (A == B) ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_swizzle_vec4_partial()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::ivec4 A(0, 1, 2, 3);
|
||||
|
||||
{
|
||||
glm::ivec4 B(A.swizzle(glm::R, glm::G, glm::B), 3);
|
||||
Error += (A == B) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::ivec4 B(A.swizzle(glm::R, glm::G), 2, 3);
|
||||
Error += (A == B) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::ivec4 B(0, A.swizzle(glm::G, glm::B), 3);
|
||||
Error += (A == B) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::ivec4 B(0, 1, A.swizzle(glm::B, glm::A));
|
||||
Error += (A == B) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::ivec4 B(A.swizzle(glm::X, glm::Y), A.swizzle(glm::Z, glm::W));
|
||||
Error += (A == B) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::ivec4 B(A.swizzle(glm::X, glm::Y), glm::vec2(2, 3));
|
||||
Error += (A == B) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::ivec4 B(glm::vec2(0, 1), A.swizzle(glm::Z, glm::W));
|
||||
Error += (A == B) ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error = 0;
|
||||
Error += test_swizzle_vec3_partial();
|
||||
Error += test_swizzle_vec4_ref_dynamic();
|
||||
Error += test_swizzle_vec4_ref_static();
|
||||
Error += test_swizzle_vec4_const_dynamic();
|
||||
Error += test_swizzle_vec4_const_static();
|
||||
Error += test_swizzle_vec4_partial();
|
||||
|
||||
return Error;
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user