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

Removed GTC_swizzle

Browse Source
master
Christophe Riccio ago%!(EXTRA string=12 years)
parent 0464c836cb
commit 8e955736ac
4 changed files with 0 additions and 701 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 381
      glm/gtc/swizzle.hpp
  2. 116
      glm/gtc/swizzle.inl
  3. 1
      test/gtc/CMakeLists.txt
  4. 203
      test/gtc/gtc_swizzle.cpp

381
glm/gtc/swizzle.hpp
Unescape View File

@ -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

116
glm/gtc/swizzle.inl
Unescape View File

@ -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

1
test/gtc/CMakeLists.txt
Unescape View File

@ -10,7 +10,6 @@ glmCreateTestGTC(gtc_packing)
glmCreateTestGTC(gtc_quaternion) glmCreateTestGTC(gtc_quaternion)
glmCreateTestGTC(gtc_random) glmCreateTestGTC(gtc_random)
glmCreateTestGTC(gtc_reciprocal) glmCreateTestGTC(gtc_reciprocal)
glmCreateTestGTC(gtc_swizzle)
glmCreateTestGTC(gtc_type_precision) glmCreateTestGTC(gtc_type_precision)
glmCreateTestGTC(gtc_type_ptr) glmCreateTestGTC(gtc_type_ptr)
glmCreateTestGTC(gtc_ulp) glmCreateTestGTC(gtc_ulp)

203
test/gtc/gtc_swizzle.cpp
Unescape View File

@ -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;
}
Write Preview
Loading…
Cancel
Save