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

Updated swizzle impl and tests

Browse Source
master
Christophe Riccio ago%!(EXTRA string=14 years)
parent e145f7e389
commit b77d66317e
5 changed files with 368 additions and 134 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. 373
      glm/gtc/swizzle.inl
  2. 2
      test/CMakeLists.txt
  3. 89
      test/gtc/gtc-swizzle.cpp
  4. 0
      test/test.cpp
  5. 38
      test/test.hpp

373
glm/gtc/swizzle.inl
Unescape View File

@ -1,134 +1,249 @@
///////////////////////////////////////////////////////////////////////////////////////////////////
// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2011-01-15
// Updated : 2011-01-15
// Licence : This source is under MIT License
// File : glm/gtc/swizzle.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
// Dependency:
// - GLM core
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
namespace gtc{
namespace swizzle
{
template <typename T, template <typename> class vecType>
inline T swizzle
(
vecType<T> const & v,
comp x
)
{
assert(int(x) < int(typename vecType<T>::_size));
return v[x];
}
template <typename T>
inline detail::tvec2<T> swizzle
(
detail::tvec4<T> const & v,
comp x, comp y
)
{
return detail::tvec2<T>(
v[x],
v[y]);
}
template <typename T>
inline detail::tvec3<T> swizzle
(
detail::tvec4<T> const & v,
comp x, comp y, comp z
)
{
return detail::tvec3<T>(
v[x],
v[y],
v[z]);
}
template <typename T>
inline detail::tvec4<T> swizzle
(
detail::tvec4<T> const & v,
comp x, comp y, comp z, comp w
)
{
return detail::tvec4<T>(v[x], v[y], v[z], v[w]);
}
template <typename T>
inline detail::tref4<T> swizzle
(
detail::tvec4<T> & v,
comp x, comp y, comp z, comp w
)
{
return detail::tref4<T>(v[x], v[y], v[z], v[w]);
}
template <comp X>
inline int swizzle
(
detail::tvec4<int> const & v
)
{
return v[X];
}
template <comp X>
inline float swizzle
(
detail::tvec4<float> const & v
)
{
return v[X];
}
template <comp X, comp Y>
inline detail::tvec2<int> swizzle
(
detail::tvec4<int> const & v
)
{
return detail::tvec2<int>(v[X], v[Y]);
}
template <comp X, comp Y>
inline detail::tvec2<float> swizzle
(
detail::tvec4<float> const & v
)
{
return detail::tvec2<float>(v[X], v[Y]);
}
template <comp X, comp Y, comp Z>
inline detail::tvec3<int> swizzle
(
detail::tvec4<int> const & v
)
{
return detail::tvec3<int>(v[X], v[Y], v[Z]);
}
template <comp X, comp Y, comp Z>
inline detail::tvec3<float> swizzle
(
detail::tvec4<float> const & v
)
{
return detail::tvec3<float>(v[X], v[Y], v[Z]);
}
template <comp X, comp Y, comp Z, comp W>
inline detail::tvec4<int> swizzle
(
detail::tvec4<int> const & v
)
{
return detail::tvec4<int>(v[X], v[Y], v[Z], v[W]);
}
template <comp X, comp Y, comp Z, comp W>
inline detail::tvec4<float> swizzle
(
detail::tvec4<float> const & v
)
{
return detail::tvec4<float>(v[X], v[Y], v[Z], v[W]);
}
namespace swizzle{
template <typename T, template <typename> class vecType>
inline T swizzle
(
vecType<T> const & v,
comp x
)
{
assert(int(x) < int(typename vecType<T>::_size));
return v[x];
}
template <typename T>
inline detail::tvec2<T> swizzle
(
detail::tvec4<T> const & v,
comp x, comp y
)
{
return detail::tvec2<T>(
v[x],
v[y]);
}
template <typename T>
inline detail::tvec3<T> swizzle
(
detail::tvec4<T> const & v,
comp x, comp y, comp z
)
{
return detail::tvec3<T>(
v[x],
v[y],
v[z]);
}
template <typename T>
inline detail::tvec4<T> swizzle
(
detail::tvec4<T> const & v,
comp x, comp y, comp z, comp w
)
{
return detail::tvec4<T>(v[x], v[y], v[z], v[w]);
}
template <comp X>
inline int swizzle
(
detail::tvec4<int> const & v
)
{
return v[X];
}
template <comp X>
inline float swizzle
(
detail::tvec4<float> const & v
)
{
return v[X];
}
template <comp X, comp Y>
inline detail::tvec2<int> swizzle
(
detail::tvec4<int> const & v
)
{
return detail::tvec2<int>(v[X], v[Y]);
}
template <comp X, comp Y>
inline detail::tvec2<float> swizzle
(
detail::tvec4<float> const & v
)
{
return detail::tvec2<float>(v[X], v[Y]);
}
template <comp X, comp Y, comp Z>
inline detail::tvec3<int> swizzle
(
detail::tvec4<int> const & v
)
{
return detail::tvec3<int>(v[X], v[Y], v[Z]);
}
template <comp X, comp Y, comp Z>
inline detail::tvec3<float> swizzle
(
detail::tvec4<float> const & v
)
{
return detail::tvec3<float>(v[X], v[Y], v[Z]);
}
template <comp X, comp Y, comp Z, comp W>
inline detail::tvec4<int> swizzle
(
detail::tvec4<int> const & v
)
{
return detail::tvec4<int>(v[X], v[Y], v[Z], v[W]);
}
template <comp X, comp Y, comp Z, comp W>
inline detail::tvec4<float> swizzle
(
detail::tvec4<float> const & v
)
{
return detail::tvec4<float>(v[X], v[Y], v[Z], v[W]);
}
template <typename T>
inline T& swizzle
(
detail::tvec4<T> & v,
comp x
)
{
return v[x];
}
template <typename T>
inline detail::tref2<T> swizzle
(
detail::tvec4<T> & v,
comp x, comp y
)
{
return detail::tref2<T>(v[x], v[y]);
}
template <typename T>
inline detail::tref3<T> swizzle
(
detail::tvec4<T> & v,
comp x, comp y, comp z
)
{
return detail::tref3<T>(v[x], v[y], v[z]);
}
template <typename T>
inline detail::tref4<T> swizzle
(
detail::tvec4<T> & v,
comp x, comp y, comp z, comp w
)
{
return detail::tref4<T>(v[x], v[y], v[z], v[w]);
}
template <comp x>
inline float& swizzle
(
detail::tvec4<float> & v
)
{
return v[x];
}
template <comp x>
inline int& swizzle
(
detail::tvec4<int> & v
)
{
return v[x];
}
template <comp x, comp y>
inline detail::tref2<float> swizzle
(
detail::tvec4<float> & v
)
{
return detail::tref2<float>(v[x], v[y]);
}
template <comp x, comp y>
inline detail::tref2<int> swizzle
(
detail::tvec4<int> & v
)
{
return detail::tref2<int>(v[x], v[y]);
}
template <comp x, comp y, comp z>
inline detail::tref3<float> swizzle
(
detail::tvec4<float> & v
)
{
return detail::tref3<float>(v[x], v[y], v[z]);
}
template <comp x, comp y, comp z>
inline detail::tref3<int> swizzle
(
detail::tvec4<int> & v
)
{
return detail::tref3<int>(v[x], v[y], v[z]);
}
template <comp x, comp y, comp z, comp w>
inline detail::tref4<float> swizzle
(
detail::tvec4<float> & v
)
{
return detail::tref4<float>(v[x], v[y], v[z], v[w]);
}
template <comp x, comp y, comp z, comp w>
inline detail::tref4<int> swizzle
(
detail::tvec4<int> & v
)
{
return detail::tref4<int>(v[x], v[y], v[z], v[w]);
}
}//namespace swizzle
}//namespace gtc

2
test/CMakeLists.txt
Unescape View File

@ -1,7 +1,7 @@
function(glmCreateTestGTC NAME)
set(SAMPLE_NAME test-${NAME})
add_executable(${SAMPLE_NAME} ${NAME}.cpp)
add_executable(${SAMPLE_NAME} ${NAME}.cpp ../test.hpp ../test.cpp)
endfunction(glmCreateTestGTC)
add_subdirectory(bug)

89
test/gtc/gtc-swizzle.cpp
Unescape View File

@ -11,12 +11,84 @@
#include <glm/glm.hpp>
#include <glm/gtc/swizzle.hpp>
int test_swizzle_vec4_dynamic()
int test_swizzle_vec4_ref_dynamic()
{
{
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;
assert(A.x == B.x && A.y == B.y && A.z == B.z && A.w == B.w);
}
{
glm::ivec4 A(0, 1, 2, 3);
glm::ivec3 B(2, 1, 0);
glm::swizzle(A, glm::Z, glm::Y, glm::X) = B;
assert(A.x == B.x && A.y == B.y && A.z == B.z);
}
{
glm::ivec4 A(0, 1, 2, 3);
glm::ivec2 B(2, 1);
glm::swizzle(A, glm::Z, glm::Y) = B;
assert(A.x == B.x && A.y == B.y);
}
{
glm::ivec4 A(0, 1, 2, 3);
int B(2);
glm::swizzle(A, glm::Z) = B;
assert(A.x == B.x && A.y == B.y);
}
return 0;
}
int test_swizzle_vec4_ref_static()
{
{
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;
assert(A.x == B.x && A.y == B.y && A.z == B.z && A.w == B.w);
}
{
glm::ivec4 A(0, 1, 2, 3);
glm::ivec3 B(2, 1, 0);
glm::swizzle<glm::Z, glm::Y, glm::X>(A) = B;
assert(A.x == B.x && A.y == B.y && A.z == B.z);
}
{
glm::ivec4 A(0, 1, 2, 3);
glm::ivec2 B(2, 1);
glm::swizzle<glm::Z, glm::Y>(A) = B;
assert(A.x == B.x && A.y == B.y);
}
{
glm::ivec4 A(0, 1, 2, 3);
int B(2);
glm::swizzle<glm::Z>(A) = B;
assert(A.x == B.x && A.y == B.y);
}
return 0;
}
int test_swizzle_vec4_const_dynamic()
{
glm::ivec4 A(0, 1, 2, 3);
glm::ivec4 B = glm::swizzle(A, glm::B, glm::G, glm::R, glm::A);
assert(glm::all(glm::equal(A, B)));
glm::ivec3 C = glm::swizzle(A, glm::W, glm::Y, glm::Z);
assert(glm::all(glm::equal(A, C)));
glm::ivec2 D = glm::swizzle(A, glm::W, glm::X);
assert(glm::all(glm::equal(A, D)));
assert(D.x == A.w && D.y == A.x);
int E = glm::swizzle(A, glm::Q);
assert(E == A.q);
@ -24,12 +96,19 @@ int test_swizzle_vec4_dynamic()
return 0;
}
int test_swizzle_vec4_static()
int test_swizzle_vec4_const_static()
{
glm::ivec4 A(0, 1, 2, 3);
glm::ivec4 B = glm::swizzle<glm::B, glm::G, glm::R, glm::A>(A);
assert(glm::all(glm::equal(A, B)));
glm::ivec3 C = glm::swizzle<glm::W, glm::Y, glm::Z>(A);
assert(glm::all(glm::equal(A, C)));
glm::ivec2 D = glm::swizzle<glm::W, glm::X>(A);
assert(glm::all(glm::equal(A, D)));
int E = glm::swizzle<glm::Q>(A);
assert(E == A.q);
@ -39,8 +118,10 @@ int test_swizzle_vec4_static()
int main(int argc, void* argv[])
{
int Failed = 0;
Failed += test_swizzle_vec4_dynamic();
Failed += test_swizzle_vec4_static();
Failed += test_swizzle_vec4_ref_dynamic();
Failed += test_swizzle_vec4_ref_static();
Failed += test_swizzle_vec4_const_dynamic();
Failed += test_swizzle_vec4_const_static();
return Failed;
}

0
test/test.cpp
Unescape View File

38
test/test.hpp
Unescape View File

@ -0,0 +1,38 @@
#ifndef glm_test_included
#define glm_test_included
#include <string>
namespace glm{
namespace test
{
class test
{
enum result
{
PASSED,
FAILED,
ASSERT,
STATIC,
MAX
};
public:
test(std::string const & Name, std::size_t const & Count);
result & operator[](std::size_t const & Index);
result const & operator[](std::size_t const & Index) const;
static int get(result const Result) const;
static void log(test const & Test);
protected:
std::string Name;
std::vertor<result> Tests;
static test Result[MAX];
};
}//namespace test
}//namespace glm
#endif//glm_test_included
Write Preview
Loading…
Cancel
Save