diff --git a/CMakeLists.txt b/CMakeLists.txt index 62592ca5..6d026b67 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -8,7 +8,7 @@ add_definitions(-D_CRT_SECURE_NO_WARNINGS) #add_definitions(-pedantic) #add_definitions(-S) #add_definitions(-s) -add_definitions(-msse2) +#add_definitions(-msse2) #add_definitions(-m32) #add_definitions(-mfpmath=387) #add_definitions(-ffast-math) diff --git a/glm/core/func_integer.inl b/glm/core/func_integer.inl index 98d517e9..3e4d56c8 100644 --- a/glm/core/func_integer.inl +++ b/glm/core/func_integer.inl @@ -269,13 +269,13 @@ namespace glm GLM_STATIC_ASSERT(std::numeric_limits::is_integer, "'bitfieldExtract' only accept integer values"); assert(Offset + Bits <= sizeof(genIUType)); - genIUType Result = 0; + genIUType Result(0); if(std::numeric_limits::is_signed) - Result |= (1 << (sizeof(genIUType) * 8 - 1)) & (1 << (Offset + Bits - 1)); + Result |= (genIUType(1) << (sizeof(genIUType) * genIUType(8) - genIUType(1))) & (genIUType(1) << (Offset + Bits - genIUType(1))); - genIUType Mask = 0; + genIUType Mask(0); for(int Bit = Offset; Bit < Bits; ++Bit) - Mask |= (1 << Bit); + Mask |= (genIUType(1) << Bit); return Result | ((Mask & Value) >> Offset); } @@ -340,7 +340,7 @@ namespace glm genIUType Mask = 0; for(int Bit = Offset; Bit < Offset + Bits; ++Bit) - Mask |= (1 << Bit); + Mask |= (genIUType(1) << Bit); return (Base & ~Mask) | (Insert & Mask); } @@ -398,8 +398,8 @@ namespace glm genIUType Result = 0; for(std::size_t i = 0; i < sizeof(genIUType) * std::size_t(8); ++i) - if(Value & (1 << i)) - Result |= (genIUType(1) << (sizeof(genIUType) * std::size_t(8)) - genIUType(1) - i); + if(Value & (genIUType(1) << genIUType(i))) + Result |= (genIUType(1) << (genIUType(sizeof(genIUType)) * genIUType(8)) - genIUType(1) - genIUType(i)); return Result; } @@ -448,7 +448,7 @@ namespace glm int Count = 0; for(std::size_t i = 0; i < sizeof(genIUType) * std::size_t(8); ++i) { - if(Value & (1 << i)) + if(Value & (genIUType(1) << i)) ++Count; } return Count; diff --git a/test/core/core_func_integer.cpp b/test/core/core_func_integer.cpp index 5c3f3cc0..948626f5 100644 --- a/test/core/core_func_integer.cpp +++ b/test/core/core_func_integer.cpp @@ -1,148 +1,135 @@ /////////////////////////////////////////////////////////////////////////////////////////////////// // OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net) /////////////////////////////////////////////////////////////////////////////////////////////////// -// Created : 2011-01-15 -// Updated : 2011-01-15 +// Created : 2011-05-03 +// Updated : 2011-05-03 // Licence : This source is under MIT licence -// File : test/gtx/simd-mat4.cpp +// File : test/core/func_integer.cpp /////////////////////////////////////////////////////////////////////////////////////////////////// -#define GLM_INSTRUCTION_SET GLM_PLATFORM_SSE3 | GLM_PLATFORM_SSE2 #include +#include +#include -int test_static_assert() +enum result { - //glm::lessThan(glm::mat4(0), glm::mat4(4)); + SUCCESS, + FAIL, + ASSERT, + STATIC_ASSERT +}; - return 0; -} - -int test_lessThan_vec2() +namespace extractField { - glm::bvec2 O = glm::bvec2(true, false); + template + struct type + { + genType Value; + sizeType BitFirst; + sizeType BitCount; + genType Return; + result Result; + }; - glm::bvec2 A = glm::lessThan(glm::vec2(0, 6), glm::vec2(4, 2)); - assert(glm::all(glm::equal(O, A))); + typedef type typeU64; - glm::bvec2 B = glm::lessThan(glm::ivec2(0, 6), glm::ivec2(4, 2)); - assert(glm::all(glm::equal(O, B))); + typeU64 const Data64[] = + { + {0xffffffffffffffff, 8, 0, 0x0000000000000000, SUCCESS}, + {0x0000000000000000, 0,64, 0x0000000000000000, SUCCESS}, + {0xffffffffffffffff, 0,64, 0xffffffffffffffff, SUCCESS}, + {0x0f0f0f0f0f0f0f0f, 0,64, 0x0f0f0f0f0f0f0f0f, SUCCESS}, + {0x0000000000000000, 8, 0, 0x0000000000000000, SUCCESS}, + {0x8000000000000000,63, 1, 0x0000000000000001, SUCCESS}, + {0x7fffffffffffffff,63, 1, 0x0000000000000000, SUCCESS}, + {0x0000000000000300, 8, 8, 0x0000000000000003, SUCCESS}, + {0x000000000000ff00, 8, 8, 0x00000000000000ff, SUCCESS}, + {0xfffffffffffffff0, 0, 5, 0x0000000000000010, SUCCESS}, + {0x00000000000000ff, 1, 3, 0x0000000000000007, SUCCESS}, + {0x00000000000000ff, 0, 3, 0x0000000000000007, SUCCESS}, + {0x0000000000000000, 0, 2, 0x0000000000000000, SUCCESS}, + {0xffffffffffffffff, 0, 8, 0x00000000000000ff, SUCCESS}, + {0xffffffff00000000,32,32, 0x00000000ffffffff, SUCCESS}, + {0xfffffffffffffff0, 0, 8, 0x0000000000000000, FAIL}, + {0xffffffffffffffff,32,32, 0x0000000000000000, FAIL}, + //{0xffffffffffffffff,64, 1, 0x0000000000000000, ASSERT}, // Throw an assert + //{0xffffffffffffffff, 0,65, 0x0000000000000000, ASSERT}, // Throw an assert + //{0xffffffffffffffff,33,32, 0x0000000000000000, ASSERT}, // Throw an assert + }; - glm::bvec2 C = glm::lessThan(glm::uvec2(0, 6), glm::uvec2(4, 2)); - assert(glm::all(glm::equal(O, C))); + int test() + { + glm::uint32 count = sizeof(Data64) / sizeof(typeU64); + + for(glm::uint32 i = 0; i < count; ++i) + { + glm::uint64 Return = glm::bitfieldExtract( + Data64[i].Value, + Data64[i].BitFirst, + Data64[i].BitCount); + + bool Compare = Data64[i].Return == Return; + + if(Data64[i].Result == SUCCESS && Compare) + continue; + else if(Data64[i].Result == FAIL && !Compare) + continue; + + std::cout << "glm::bitfieldExtract test fail on test " << i << std::endl; + return 1; + } + + return 0; + } +}//extractField - return 0; -} - -int test_lessThan_vec3() +namespace bitRevert { - glm::bvec3 O = glm::bvec3(true, true, false); + template + struct type + { + genType Value; + genType Return; + result Result; + }; - glm::bvec3 A = glm::lessThan(glm::vec3(0, 1, 6), glm::vec3(4, 5, 2)); - assert(glm::all(glm::equal(O, A))); + typedef type typeU64; - glm::bvec3 B = glm::lessThan(glm::ivec3(0, 1, 6), glm::ivec3(4, 5, 2)); - assert(glm::all(glm::equal(O, B))); - - glm::bvec3 C = glm::lessThan(glm::uvec3(0, 1, 6), glm::uvec3(4, 5, 2)); - assert(glm::all(glm::equal(O, C))); - - return 0; -} - -int test_lessThan_vec4() -{ - glm::bvec4 O = glm::bvec4(true, true, false, false); - - glm::bvec4 A = glm::lessThan(glm::vec4(0, 1, 6, 7), glm::vec4(4, 5, 2, 3)); - assert(glm::all(glm::equal(O, A))); - - glm::bvec4 B = glm::lessThan(glm::ivec4(0, 1, 6, 7), glm::ivec4(4, 5, 2, 3)); - assert(glm::all(glm::equal(O, B))); - - glm::bvec4 C = glm::lessThan(glm::uvec4(0, 1, 6, 7), glm::uvec4(4, 5, 2, 3)); - assert(glm::all(glm::equal(O, C))); - - return 0; -} - -int test_greaterThanEqual_vec2() -{ - glm::bvec2 O = glm::bvec2(false, true); - - glm::bvec2 A = glm::greaterThanEqual(glm::vec2(0, 6), glm::vec2(4, 2)); - assert(glm::all(glm::equal(O, A))); - - glm::bvec2 B = glm::greaterThanEqual(glm::ivec2(0, 6), glm::ivec2(4, 2)); - assert(glm::all(glm::equal(O, B))); - - glm::bvec2 C = glm::greaterThanEqual(glm::uvec2(0, 6), glm::uvec2(4, 2)); - assert(glm::all(glm::equal(O, C))); - - return 0; -} - -int test_greaterThanEqual_vec3() -{ - glm::bvec3 O = glm::bvec3(false, false, true); - - glm::bvec3 A = glm::greaterThanEqual(glm::vec3(0, 1, 6), glm::vec3(4, 5, 2)); - assert(glm::all(glm::equal(O, A))); - - glm::bvec3 B = glm::greaterThanEqual(glm::ivec3(0, 1, 6), glm::ivec3(4, 5, 2)); - assert(glm::all(glm::equal(O, B))); - - glm::bvec3 C = glm::greaterThanEqual(glm::uvec3(0, 1, 6), glm::uvec3(4, 5, 2)); - assert(glm::all(glm::equal(O, C))); - - return 0; -} - -int test_greaterThanEqual_vec4() -{ - glm::bvec4 O = glm::bvec4(false, false, true, true); - - glm::bvec4 A = glm::greaterThanEqual(glm::vec4(0, 1, 6, 7), glm::vec4(4, 5, 2, 3)); - assert(glm::all(glm::equal(O, A))); - - glm::bvec4 B = glm::greaterThanEqual(glm::ivec4(0, 1, 6, 7), glm::ivec4(4, 5, 2, 3)); - assert(glm::all(glm::equal(O, B))); - - glm::bvec4 C = glm::greaterThanEqual(glm::uvec4(0, 1, 6, 7), glm::uvec4(4, 5, 2, 3)); - assert(glm::all(glm::equal(O, C))); - - return 0; -} - -int test_all() -{ - assert(glm::all(glm::bvec2(true, true))); - assert(!glm::all(glm::bvec2(true, false))); - assert(!glm::all(glm::bvec2(false, false))); - - assert(glm::all(glm::bvec3(true, true, true))); - assert(!glm::all(glm::bvec3(true, false, true))); - assert(!glm::all(glm::bvec3(false, false, false))); - - assert(glm::all(glm::bvec4(true, true, true, true))); - assert(!glm::all(glm::bvec4(true, false, true, false))); - assert(!glm::all(glm::bvec4(false, false, false, false))); - - return 0; -} + typeU64 const Data64[] = + { + {0xffffffffffffffff, 0xffffffffffffffff, SUCCESS}, + {0x0000000000000000, 0x0000000000000000, SUCCESS}, + {0xf000000000000000, 0x000000000000000f, SUCCESS}, + }; + int test() + { + glm::uint32 count = sizeof(Data64) / sizeof(typeU64); + + for(glm::uint32 i = 0; i < count; ++i) + { + glm::uint64 Return = glm::bitfieldReverse( + Data64[i].Value); + + bool Compare = Data64[i].Return == Return; + + if(Data64[i].Result == SUCCESS && Compare) + continue; + else if(Data64[i].Result == FAIL && !Compare) + continue; + + std::cout << "glm::bitfieldReverse test fail on test " << i << std::endl; + return 1; + } + + return 0; + } +}//bitRevert int main() { - int Failed = 0; - Failed += test_static_assert(); - Failed += test_lessThan_vec2(); - Failed += test_lessThan_vec3(); - Failed += test_lessThan_vec4(); - Failed += test_greaterThanEqual_vec2(); - Failed += test_greaterThanEqual_vec3(); - Failed += test_greaterThanEqual_vec4(); - Failed += test_all(); - - return Failed; + int Error = 0; + Error += ::extractField::test(); + Error += ::bitRevert::test(); + return Error; } - diff --git a/test/gtx/gtx-bit.cpp b/test/gtx/gtx-bit.cpp index 7133b60f..13c9178b 100644 --- a/test/gtx/gtx-bit.cpp +++ b/test/gtx/gtx-bit.cpp @@ -129,7 +129,7 @@ namespace bitRevert int main() { - bool Error = 0; + int Error = 0; Error += ::extractField::test(); Error += ::bitRevert::test(); return Error;