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

Added EXT_vector_integer extension

Browse Source
master
Christophe Riccio ago%!(EXTRA string=6 years)
parent 07c6d56b5f
commit a91fb705db
4 changed files with 272 additions and 464 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. 2
      glm/ext/vector_integer.hpp
  2. 312
      glm/ext/vector_integer.inl
  3. 376
      test/ext/ext_vector_integer.cpp
  4. 8
      test/ext/ext_vector_integer_sized.cpp

2
glm/ext/vector_integer.hpp
Unescape View File

@ -101,7 +101,7 @@ namespace glm
/// @param v Source values to which is applied the function /// @param v Source values to which is applied the function
/// @param Multiple Must be a null or positive value /// @param Multiple Must be a null or positive value
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_DECL vec<L, T, Q> prevMultiple(vec<L, T, Q> const& v, T const& Multiple); GLM_FUNC_DECL vec<L, T, Q> prevMultiple(vec<L, T, Q> const& v, T Multiple);
/// Lower multiple number of Source. /// Lower multiple number of Source.
/// ///

312
glm/ext/vector_integer.inl
Unescape View File

@ -1,223 +1,7 @@
/// @ref gtc_round #include "scalar_integer.hpp"
#include "../integer.hpp" namespace glm
namespace glm{
namespace detail
{
template<length_t L, typename T, qualifier Q, bool compute = false>
struct compute_ceilShift
{
GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v, T)
{
return v;
}
};
template<length_t L, typename T, qualifier Q>
struct compute_ceilShift<L, T, Q, true>
{
GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v, T Shift)
{
return v | (v >> Shift);
}
};
template<length_t L, typename T, qualifier Q, bool isSigned = true>
struct compute_ceilPowerOfTwo
{
GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
{
GLM_STATIC_ASSERT(!std::numeric_limits<T>::is_iec559, "'ceilPowerOfTwo' only accept integer scalar or vector inputs");
vec<L, T, Q> const Sign(sign(x));
vec<L, T, Q> v(abs(x));
v = v - static_cast<T>(1);
v = v | (v >> static_cast<T>(1));
v = v | (v >> static_cast<T>(2));
v = v | (v >> static_cast<T>(4));
v = compute_ceilShift<L, T, Q, sizeof(T) >= 2>::call(v, 8);
v = compute_ceilShift<L, T, Q, sizeof(T) >= 4>::call(v, 16);
v = compute_ceilShift<L, T, Q, sizeof(T) >= 8>::call(v, 32);
return (v + static_cast<T>(1)) * Sign;
}
};
template<length_t L, typename T, qualifier Q>
struct compute_ceilPowerOfTwo<L, T, Q, false>
{
GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
{
GLM_STATIC_ASSERT(!std::numeric_limits<T>::is_iec559, "'ceilPowerOfTwo' only accept integer scalar or vector inputs");
vec<L, T, Q> v(x);
v = v - static_cast<T>(1);
v = v | (v >> static_cast<T>(1));
v = v | (v >> static_cast<T>(2));
v = v | (v >> static_cast<T>(4));
v = compute_ceilShift<L, T, Q, sizeof(T) >= 2>::call(v, 8);
v = compute_ceilShift<L, T, Q, sizeof(T) >= 4>::call(v, 16);
v = compute_ceilShift<L, T, Q, sizeof(T) >= 8>::call(v, 32);
return v + static_cast<T>(1);
}
};
template<bool is_float, bool is_signed>
struct compute_ceilMultiple{};
template<>
struct compute_ceilMultiple<true, true>
{
template<typename genType>
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
{
if(Source > genType(0))
return Source + (Multiple - std::fmod(Source, Multiple));
else
return Source + std::fmod(-Source, Multiple);
}
};
template<>
struct compute_ceilMultiple<false, false>
{
template<typename genType>
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
{
genType Tmp = Source - genType(1);
return Tmp + (Multiple - (Tmp % Multiple));
}
};
template<>
struct compute_ceilMultiple<false, true>
{
template<typename genType>
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
{
if(Source > genType(0))
{
genType Tmp = Source - genType(1);
return Tmp + (Multiple - (Tmp % Multiple));
}
else
return Source + (-Source % Multiple);
}
};
template<bool is_float, bool is_signed>
struct compute_floorMultiple{};
template<>
struct compute_floorMultiple<true, true>
{
template<typename genType>
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
{
if(Source >= genType(0))
return Source - std::fmod(Source, Multiple);
else
return Source - std::fmod(Source, Multiple) - Multiple;
}
};
template<>
struct compute_floorMultiple<false, false>
{
template<typename genType>
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
{
if(Source >= genType(0))
return Source - Source % Multiple;
else
{
genType Tmp = Source + genType(1);
return Tmp - Tmp % Multiple - Multiple;
}
}
};
template<>
struct compute_floorMultiple<false, true>
{
template<typename genType>
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
{
if(Source >= genType(0))
return Source - Source % Multiple;
else
{
genType Tmp = Source + genType(1);
return Tmp - Tmp % Multiple - Multiple;
}
}
};
template<bool is_float, bool is_signed>
struct compute_roundMultiple{};
template<>
struct compute_roundMultiple<true, true>
{
template<typename genType>
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
{
if(Source >= genType(0))
return Source - std::fmod(Source, Multiple);
else
{
genType Tmp = Source + genType(1);
return Tmp - std::fmod(Tmp, Multiple) - Multiple;
}
}
};
template<>
struct compute_roundMultiple<false, false>
{
template<typename genType>
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
{
if(Source >= genType(0))
return Source - Source % Multiple;
else
{
genType Tmp = Source + genType(1);
return Tmp - Tmp % Multiple - Multiple;
}
}
};
template<>
struct compute_roundMultiple<false, true>
{
template<typename genType>
GLM_FUNC_QUALIFIER static genType call(genType Source, genType Multiple)
{
if(Source >= genType(0))
return Source - Source % Multiple;
else
{
genType Tmp = Source + genType(1);
return Tmp - Tmp % Multiple - Multiple;
}
}
};
}//namespace detail
////////////////
// isPowerOfTwo
template<typename genType>
GLM_FUNC_QUALIFIER bool isPowerOfTwo(genType Value)
{ {
genType const Result = glm::abs(Value);
return !(Result & (Result - 1));
}
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, bool, Q> isPowerOfTwo(vec<L, T, Q> const& Value) GLM_FUNC_QUALIFIER vec<L, bool, Q> isPowerOfTwo(vec<L, T, Q> const& Value)
{ {
@ -225,63 +9,16 @@ namespace detail
return equal(Result & (Result - 1), vec<L, T, Q>(0)); return equal(Result & (Result - 1), vec<L, T, Q>(0));
} }
//////////////////
// ceilPowerOfTwo
template<typename genType>
GLM_FUNC_QUALIFIER genType ceilPowerOfTwo(genType value)
{
return detail::compute_ceilPowerOfTwo<1, genType, defaultp, std::numeric_limits<genType>::is_signed>::call(vec<1, genType, defaultp>(value)).x;
}
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> ceilPowerOfTwo(vec<L, T, Q> const& v) GLM_FUNC_QUALIFIER vec<L, T, Q> nextPowerOfTwo(vec<L, T, Q> const& v)
{ {
return detail::compute_ceilPowerOfTwo<L, T, Q, std::numeric_limits<T>::is_signed>::call(v); return detail::compute_ceilPowerOfTwo<L, T, Q, std::numeric_limits<T>::is_signed>::call(v);
} }
///////////////////
// floorPowerOfTwo
template<typename genType>
GLM_FUNC_QUALIFIER genType floorPowerOfTwo(genType value)
{
return isPowerOfTwo(value) ? value : static_cast<genType>(1) << findMSB(value);
}
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> floorPowerOfTwo(vec<L, T, Q> const& v) GLM_FUNC_QUALIFIER vec<L, T, Q> prevPowerOfTwo(vec<L, T, Q> const& v)
{
return detail::functor1<vec, L, T, T, Q>::call(floorPowerOfTwo, v);
}
///////////////////
// roundPowerOfTwo
template<typename genIUType>
GLM_FUNC_QUALIFIER genIUType roundPowerOfTwo(genIUType value)
{ {
if(isPowerOfTwo(value)) return detail::functor1<vec, L, T, T, Q>::call(prevPowerOfTwo, v);
return value;
genIUType const prev = static_cast<genIUType>(1) << findMSB(value);
genIUType const next = prev << static_cast<genIUType>(1);
return (next - value) < (value - prev) ? next : prev;
}
template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> roundPowerOfTwo(vec<L, T, Q> const& v)
{
return detail::functor1<vec, L, T, T, Q>::call(roundPowerOfTwo, v);
}
////////////////
// isMultiple
template<typename genType>
GLM_FUNC_QUALIFIER bool isMultiple(genType Value, genType Multiple)
{
return isMultiple(vec<1, genType>(Value), vec<1, genType>(Multiple)).x;
} }
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
@ -296,48 +33,27 @@ namespace detail
return (Value % Multiple) == vec<L, T, Q>(0); return (Value % Multiple) == vec<L, T, Q>(0);
} }
//////////////////////
// ceilMultiple
template<typename genType>
GLM_FUNC_QUALIFIER genType ceilMultiple(genType Source, genType Multiple)
{
return detail::compute_ceilMultiple<std::numeric_limits<genType>::is_iec559, std::numeric_limits<genType>::is_signed>::call(Source, Multiple);
}
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> ceilMultiple(vec<L, T, Q> const& Source, vec<L, T, Q> const& Multiple) GLM_FUNC_QUALIFIER vec<L, T, Q> nextMultiple(vec<L, T, Q> const& Source, T Multiple)
{ {
return detail::functor2<vec, L, T, Q>::call(ceilMultiple, Source, Multiple); return detail::functor2<vec, L, T, Q>::call(nextMultiple, Source, vec<L, T, Q>(Multiple));
}
//////////////////////
// floorMultiple
template<typename genType>
GLM_FUNC_QUALIFIER genType floorMultiple(genType Source, genType Multiple)
{
return detail::compute_floorMultiple<std::numeric_limits<genType>::is_iec559, std::numeric_limits<genType>::is_signed>::call(Source, Multiple);
} }
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> floorMultiple(vec<L, T, Q> const& Source, vec<L, T, Q> const& Multiple) GLM_FUNC_QUALIFIER vec<L, T, Q> nextMultiple(vec<L, T, Q> const& Source, vec<L, T, Q> const& Multiple)
{ {
return detail::functor2<vec, L, T, Q>::call(floorMultiple, Source, Multiple); return detail::functor2<vec, L, T, Q>::call(nextMultiple, Source, Multiple);
} }
////////////////////// template<length_t L, typename T, qualifier Q>
// roundMultiple GLM_FUNC_QUALIFIER vec<L, T, Q> prevMultiple(vec<L, T, Q> const& Source, T Multiple)
template<typename genType>
GLM_FUNC_QUALIFIER genType roundMultiple(genType Source, genType Multiple)
{ {
return detail::compute_roundMultiple<std::numeric_limits<genType>::is_iec559, std::numeric_limits<genType>::is_signed>::call(Source, Multiple); return detail::functor2<vec, L, T, Q>::call(prevMultiple, Source, vec<L, T, Q>(Multiple));
} }
template<length_t L, typename T, qualifier Q> template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> roundMultiple(vec<L, T, Q> const& Source, vec<L, T, Q> const& Multiple) GLM_FUNC_QUALIFIER vec<L, T, Q> prevMultiple(vec<L, T, Q> const& Source, vec<L, T, Q> const& Multiple)
{ {
return detail::functor2<vec, L, T, Q>::call(roundMultiple, Source, Multiple); return detail::functor2<vec, L, T, Q>::call(prevMultiple, Source, Multiple);
} }
}//namespace glm }//namespace glm

376
test/ext/ext_vector_integer.cpp
Unescape View File

@ -1,211 +1,309 @@
#include <glm/ext/vector_integer.hpp> #include <glm/ext/vector_integer.hpp>
#include <glm/ext/vector_int1.hpp> #include <glm/ext/scalar_int_sized.hpp>
#include <glm/ext/vector_int2.hpp> #include <glm/ext/scalar_uint_sized.hpp>
#include <glm/ext/vector_int3.hpp> #include <vector>
#include <glm/ext/vector_int4.hpp> #include <ctime>
#include <glm/ext/vector_uint1.hpp> #include <cstdio>
#include <glm/ext/vector_uint2.hpp>
#include <glm/ext/vector_uint3.hpp>
#include <glm/ext/vector_uint4.hpp>
#include <glm/vector_relational.hpp>
namespace isPowerOfTwo
{
template<typename genType> template<typename genType>
static int test_operators() struct type
{
genType Value;
bool Return;
};
int test_int16()
{ {
type<glm::int16> const Data[] =
{
{ 0x0001, true },
{ 0x0002, true },
{ 0x0004, true },
{ 0x0080, true },
{ 0x0000, true },
{ 0x0003, false }
};
int Error = 0; int Error = 0;
for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::int16>); i < n; ++i)
{ {
genType const A(1); bool Result = glm::isPowerOfTwo(Data[i].Value);
genType const B(1); Error += Data[i].Return == Result ? 0 : 1;
}
bool const R = A != B; return Error;
bool const S = A == B;
Error += (S && !R) ? 0 : 1;
} }
int test_uint16()
{ {
genType const A(1); type<glm::uint16> const Data[] =
genType const B(1); {
{ 0x0001, true },
genType const C = A + B; { 0x0002, true },
Error += C == genType(2) ? 0 : 1; { 0x0004, true },
{ 0x0000, true },
{ 0x0000, true },
{ 0x0003, false }
};
genType const D = A - B; int Error = 0;
Error += D == genType(0) ? 0 : 1;
genType const E = A * B; for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::uint16>); i < n; ++i)
Error += E == genType(1) ? 0 : 1; {
bool Result = glm::isPowerOfTwo(Data[i].Value);
Error += Data[i].Return == Result ? 0 : 1;
}
genType const F = A / B; return Error;
Error += F == genType(1) ? 0 : 1;
} }
int test_int32()
{
type<int> const Data[] =
{
{ 0x00000001, true },
{ 0x00000002, true },
{ 0x00000004, true },
{ 0x0000000f, false },
{ 0x00000000, true },
{ 0x00000003, false }
};
int Error = 0;
for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<int>); i < n; ++i)
{ {
genType const A(3); bool Result = glm::isPowerOfTwo(Data[i].Value);
genType const B(2); Error += Data[i].Return == Result ? 0 : 1;
}
genType const C = A % B; return Error;
Error += C == genType(1) ? 0 : 1;
} }
int test_uint32()
{ {
genType const A(1); type<glm::uint> const Data[] =
genType const B(1); {
genType const C(0); { 0x00000001, true },
{ 0x00000002, true },
{ 0x00000004, true },
{ 0x80000000, true },
{ 0x00000000, true },
{ 0x00000003, false }
};
genType const I = A & B; int Error = 0;
Error += I == genType(1) ? 0 : 1;
genType const D = A & C;
Error += D == genType(0) ? 0 : 1;
genType const E = A | B; for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<glm::uint>); i < n; ++i)
Error += E == genType(1) ? 0 : 1; {
genType const F = A | C; bool Result = glm::isPowerOfTwo(Data[i].Value);
Error += F == genType(1) ? 0 : 1; Error += Data[i].Return == Result ? 0 : 1;
}
genType const G = A ^ B; return Error;
Error += G == genType(0) ? 0 : 1;
genType const H = A ^ C;
Error += H == genType(1) ? 0 : 1;
} }
int test()
{ {
genType const A(0); int Error = 0;
genType const B(1);
genType const C(2); Error += test_int16();
Error += test_uint16();
Error += test_int32();
Error += test_uint32();
genType const D = B << B; return Error;
Error += D == genType(2) ? 0 : 1;
genType const E = C >> B;
Error += E == genType(1) ? 0 : 1;
} }
}//isPowerOfTwo
namespace prevPowerOfTwo
{
template <typename T>
int run()
{
int Error = 0;
T const A = glm::prevPowerOfTwo(static_cast<T>(7));
Error += A == static_cast<T>(4) ? 0 : 1;
T const B = glm::prevPowerOfTwo(static_cast<T>(15));
Error += B == static_cast<T>(8) ? 0 : 1;
T const C = glm::prevPowerOfTwo(static_cast<T>(31));
Error += C == static_cast<T>(16) ? 0 : 1;
T const D = glm::prevPowerOfTwo(static_cast<T>(32));
Error += D == static_cast<T>(32) ? 0 : 1;
return Error; return Error;
} }
template <typename genType> int test()
static int test_ctor()
{ {
typedef typename genType::value_type T; int Error = 0;
Error += run<glm::int8>();
Error += run<glm::int16>();
Error += run<glm::int32>();
Error += run<glm::int64>();
Error += run<glm::uint8>();
Error += run<glm::uint16>();
Error += run<glm::uint32>();
Error += run<glm::uint64>();
return Error;
}
}//namespace prevPowerOfTwo
namespace nextPowerOfTwo
{
template <typename T>
int run()
{
int Error = 0; int Error = 0;
genType const A = genType(1); T const A = glm::nextPowerOfTwo(static_cast<T>(7));
Error += A == static_cast<T>(8) ? 0 : 1;
genType const E(genType(1)); T const B = glm::nextPowerOfTwo(static_cast<T>(15));
Error += A == E ? 0 : 1; Error += B == static_cast<T>(16) ? 0 : 1;
genType const F(E); T const C = glm::nextPowerOfTwo(static_cast<T>(31));
Error += A == F ? 0 : 1; Error += C == static_cast<T>(32) ? 0 : 1;
genType const B = genType(1); T const D = glm::nextPowerOfTwo(static_cast<T>(32));
genType const G(glm::vec<2, T>(1)); Error += D == static_cast<T>(32) ? 0 : 1;
Error += B == G ? 0 : 1;
return Error;
}
int test()
{
int Error = 0;
genType const H(glm::vec<3, T>(1)); Error += run<glm::int8>();
Error += B == H ? 0 : 1; Error += run<glm::int16>();
Error += run<glm::int32>();
Error += run<glm::int64>();
genType const I(glm::vec<4, T>(1)); Error += run<glm::uint8>();
Error += B == I ? 0 : 1; Error += run<glm::uint16>();
Error += run<glm::uint32>();
Error += run<glm::uint64>();
return Error; return Error;
} }
}//namespace nextPowerOfTwo
template <typename genType> namespace prevMultiple
static int test_size() {
template<typename genIUType>
struct type
{
genIUType Source;
genIUType Multiple;
genIUType Return;
};
template <typename T>
int run()
{ {
type<T> const Data[] =
{
{ 8, 3, 6 },
{ 7, 7, 7 }
};
int Error = 0; int Error = 0;
Error += sizeof(typename genType::value_type) == sizeof(genType) ? 0 : 1; for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<T>); i < n; ++i)
Error += genType().length() == 1 ? 0 : 1; {
Error += genType::length() == 1 ? 0 : 1; glm::vec<4, T> const Result = glm::prevMultiple(glm::vec<4, T>(Data[i].Source), Data[i].Multiple);
Error += glm::vec<4, T>(Data[i].Return) == Result ? 0 : 1;
}
return Error; return Error;
} }
template <typename genType> int test()
static int test_relational()
{ {
int Error = 0; int Error = 0;
genType const A(1); Error += run<glm::int8>();
genType const B(1); Error += run<glm::int16>();
genType const C(0); Error += run<glm::int32>();
Error += run<glm::int64>();
Error += A == B ? 0 : 1; Error += run<glm::uint8>();
Error += A != C ? 0 : 1; Error += run<glm::uint16>();
Error += all(equal(A, B)) ? 0 : 1; Error += run<glm::uint32>();
Error += any(notEqual(A, C)) ? 0 : 1; Error += run<glm::uint64>();
return Error; return Error;
} }
}//namespace prevMultiple
template <typename genType> namespace nextMultiple
static int test_constexpr() {
template<typename genIUType>
struct type
{
genIUType Source;
genIUType Multiple;
genIUType Return;
};
template <typename T>
int run()
{
type<T> const Data[] =
{ {
# if GLM_CONFIG_CONSTEXP == GLM_ENABLE { 8, 3, 6 },
static_assert(genType::length() == 1, "GLM: Failed constexpr"); { 7, 7, 7 }
static_assert(genType(1)[0] == 1, "GLM: Failed constexpr"); };
static_assert(genType(1) == genType(1), "GLM: Failed constexpr");
static_assert(genType(1) != genType(0), "GLM: Failed constexpr"); int Error = 0;
# endif
for (std::size_t i = 0, n = sizeof(Data) / sizeof(type<T>); i < n; ++i)
{
glm::vec<4, T> const Result = glm::nextMultiple(glm::vec<4, T>(Data[i].Source), Data[i].Multiple);
Error += glm::vec<4, T>(Data[i].Return) == Result ? 0 : 1;
}
return 0; return Error;
}
int test()
{
int Error = 0;
Error += run<glm::int8>();
Error += run<glm::int16>();
Error += run<glm::int32>();
Error += run<glm::int64>();
Error += run<glm::uint8>();
Error += run<glm::uint16>();
Error += run<glm::uint32>();
Error += run<glm::uint64>();
return Error;
} }
}//namespace nextMultiple
int main() int main()
{ {
int Error = 0; int Error = 0;
Error += test_operators<glm::ivec1>(); Error += isPowerOfTwo::test();
Error += test_operators<glm::lowp_ivec1>(); Error += prevPowerOfTwo::test();
Error += test_operators<glm::mediump_ivec1>(); Error += nextPowerOfTwo::test();
Error += test_operators<glm::highp_ivec1>(); Error += prevMultiple::test();
Error += nextMultiple::test();
Error += test_ctor<glm::ivec1>();
Error += test_ctor<glm::lowp_ivec1>();
Error += test_ctor<glm::mediump_ivec1>();
Error += test_ctor<glm::highp_ivec1>();
Error += test_size<glm::ivec1>();
Error += test_size<glm::lowp_ivec1>();
Error += test_size<glm::mediump_ivec1>();
Error += test_size<glm::highp_ivec1>();
Error += test_relational<glm::ivec1>();
Error += test_relational<glm::lowp_ivec1>();
Error += test_relational<glm::mediump_ivec1>();
Error += test_relational<glm::highp_ivec1>();
Error += test_constexpr<glm::ivec1>();
Error += test_constexpr<glm::lowp_ivec1>();
Error += test_constexpr<glm::mediump_ivec1>();
Error += test_constexpr<glm::highp_ivec1>();
Error += test_operators<glm::uvec1>();
Error += test_operators<glm::lowp_uvec1>();
Error += test_operators<glm::mediump_uvec1>();
Error += test_operators<glm::highp_uvec1>();
Error += test_ctor<glm::uvec1>();
Error += test_ctor<glm::lowp_uvec1>();
Error += test_ctor<glm::mediump_uvec1>();
Error += test_ctor<glm::highp_uvec1>();
Error += test_size<glm::uvec1>();
Error += test_size<glm::lowp_uvec1>();
Error += test_size<glm::mediump_uvec1>();
Error += test_size<glm::highp_uvec1>();
Error += test_relational<glm::uvec1>();
Error += test_relational<glm::lowp_uvec1>();
Error += test_relational<glm::mediump_uvec1>();
Error += test_relational<glm::highp_uvec1>();
Error += test_constexpr<glm::uvec1>();
Error += test_constexpr<glm::lowp_uvec1>();
Error += test_constexpr<glm::mediump_uvec1>();
Error += test_constexpr<glm::highp_uvec1>();
return Error; return Error;
} }

8
test/ext/ext_vector_integer_sized.cpp
Unescape View File

@ -1,14 +1,8 @@
#include <glm/ext/vector_integer.hpp>
#include <glm/ext/vector_int1.hpp> #include <glm/ext/vector_int1.hpp>
#include <glm/ext/vector_int1_precision.hpp> #include <glm/ext/vector_int1_precision.hpp>
#include <glm/ext/vector_int2.hpp>
#include <glm/ext/vector_int3.hpp>
#include <glm/ext/vector_int4.hpp>
#include <glm/ext/vector_uint1.hpp> #include <glm/ext/vector_uint1.hpp>
#include <glm/ext/vector_uint1_precision.hpp> #include <glm/ext/vector_uint1_precision.hpp>
#include <glm/ext/vector_uint2.hpp>
#include <glm/ext/vector_uint3.hpp>
#include <glm/ext/vector_uint4.hpp>
#include <glm/vector_relational.hpp>
template <typename genType> template <typename genType>
static int test_operators() static int test_operators()

Write Preview
Loading…
Cancel
Save