mewin/glm
1
0
Fork 0
Code Releases Activity

Fixed GTC_packing build

Browse Source
This commit is contained in:
Christophe Riccio 2013-09-01 18:22:47 +02:00
parent 36a5f1cc20
commit 635d2d0eca
3 changed files with 192 additions and 234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
glm/gtc/packing.inl
View File

@ -304,7 +304,7 @@ namespace detail
GLM_FUNC_QUALIFIER uint8 packUnorm1x8(float const & v) GLM_FUNC_QUALIFIER uint8 packUnorm1x8(float const & v)
{ {
int8 Scaled(round(clamp(v ,-1.0f, 1.0f) * 255.0f)); int8 Scaled(int8(round(clamp(v, -1.0f, 1.0f) * 255.0f)));
detail::unorm1x8 Packing; detail::unorm1x8 Packing;
Packing.data = Scaled; Packing.data = Scaled;
return Packing.pack; return Packing.pack;
@ -337,7 +337,7 @@ namespace detail
GLM_FUNC_QUALIFIER uint8 packSnorm1x8(float const & v) GLM_FUNC_QUALIFIER uint8 packSnorm1x8(float const & v)
{ {
glm::int8 Scaled(round(clamp(v ,-1.0f, 1.0f) * 127.0f)); glm::int8 Scaled(int8(round(clamp(v ,-1.0f, 1.0f) * 127.0f)));
detail::snorm1x8 Packing; detail::snorm1x8 Packing;
Packing.data = Scaled; Packing.data = Scaled;
return Packing.pack; return Packing.pack;

48
test/core/core_func_swizzle.cpp
View File

@ -7,24 +7,11 @@
// File : test/core/core_func_swizzle.cpp // File : test/core/core_func_swizzle.cpp
/////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////
#ifndef GLM_FORCE_ONLY_XYZW #define GLM_MESSAGES
# define GLM_FORCE_ONLY_XYZW #define GLM_SWIZZLE
#endif
//#ifndef GLM_FORCE_PURE
//# define GLM_FORCE_PURE
//#endif
#ifndef GLM_MESSAGES
# define GLM_MESSAGES
#endif
#ifndef GLM_SWIZZLE
# define GLM_SWIZZLE
#endif
#ifndef GLM_FORCE_CXX98
# define GLM_FORCE_CXX98
#endif
#include <glm/glm.hpp> #include <glm/glm.hpp>
int test_vec2_swizzle() int test_ivec2_swizzle()
{ {
int Error = 0; int Error = 0;
@ -39,7 +26,7 @@ int test_vec2_swizzle()
return Error; return Error;
} }
int test_vec3_swizzle() int test_ivec3_swizzle()
{ {
int Error = 0; int Error = 0;
@ -54,7 +41,7 @@ int test_vec3_swizzle()
return Error; return Error;
} }
int test_vec4_swizzle() int test_ivec4_swizzle()
{ {
int Error = 0; int Error = 0;
@ -69,12 +56,33 @@ int test_vec4_swizzle()
return Error; return Error;
} }
int test_vec4_swizzle()
{
int Error = 0;
glm::vec4 A(1, 2, 3, 4);
glm::vec4 B = A.xyzw();
glm::vec4 C(0);
C.xyzw = B.xyzw;
float f = glm::dot(C.wzyx(), C.xyzw());
Error += A == B ? 0 : 1;
Error += A == C ? 0 : 1;
static_assert(sizeof(int) <= 4, "Test");
return Error;
}
int main() int main()
{ {
int Error = 0; int Error = 0;
Error += test_vec2_swizzle(); Error += test_ivec2_swizzle();
Error += test_vec3_swizzle(); Error += test_ivec3_swizzle();
Error += test_ivec4_swizzle();
Error += test_vec4_swizzle(); Error += test_vec4_swizzle();
return Error; return Error;

374
test/gtc/gtc_packing.cpp
View File

@ -31,287 +31,237 @@
#include <cstdio> #include <cstdio>
#include <vector> #include <vector>
void print_bits(glm::half const & s)
{
union
{
glm::detail::hdata h;
unsigned short i;
} uif;
uif.h = s._data();
printf("f16: ");
for(std::size_t j = sizeof(s) * 8; j > 0; --j)
{
if(j == 10 || j == 15)
printf(" ");
printf("%d", (uif.i & (1 << (j - 1))) ? 1 : 0);
}
}
void print_bits(float const & s) void print_bits(float const & s)
{ {
union union
{ {
float f; float f;
unsigned int i; unsigned int i;
} uif; } uif;
uif.f = s; uif.f = s;
printf("f32: "); printf("f32: ");
for(std::size_t j = sizeof(s) * 8; j > 0; --j) for(std::size_t j = sizeof(s) * 8; j > 0; --j)
{ {
if(j == 23 || j == 31) if(j == 23 || j == 31)
printf(" "); printf(" ");
printf("%d", (uif.i & (1 << (j - 1))) ? 1 : 0); printf("%d", (uif.i & (1 << (j - 1))) ? 1 : 0);
} }
} }
void print_10bits(glm::uint const & s) void print_10bits(glm::uint const & s)
{ {
printf("10b: "); printf("10b: ");
for(std::size_t j = 10; j > 0; --j) for(std::size_t j = 10; j > 0; --j)
{ {
if(j == 5) if(j == 5)
printf(" "); printf(" ");
printf("%d", (s & (1 << (j - 1))) ? 1 : 0); printf("%d", (s & (1 << (j - 1))) ? 1 : 0);
} }
} }
void print_11bits(glm::uint const & s) void print_11bits(glm::uint const & s)
{ {
printf("11b: "); printf("11b: ");
for(std::size_t j = 11; j > 0; --j) for(std::size_t j = 11; j > 0; --j)
{ {
if(j == 6) if(j == 6)
printf(" "); printf(" ");
printf("%d", (s & (1 << (j - 1))) ? 1 : 0); printf("%d", (s & (1 << (j - 1))) ? 1 : 0);
} }
} }
void print_value(float const & s) void print_value(float const & s)
{ {
printf("%2.5f, ", s); printf("%2.5f, ", s);
print_bits(s); print_bits(s);
printf(", "); printf(", ");
print_bits(glm::half(s)); // print_11bits(detail::floatTo11bit(s));
// printf(", "); // printf(", ");
// print_11bits(detail::floatTo11bit(s)); // print_10bits(detail::floatTo10bit(s));
// printf(", "); printf("\n");
// print_10bits(detail::floatTo10bit(s));
printf("\n");
}
int test_half()
{
int Error = 0;
print_value(0.0f);
print_value(0.1f);
print_value(0.2f);
print_value(0.3f);
print_value(0.4f);
print_value(0.5f);
print_value(0.6f);
print_value(1.0f);
print_value(1.1f);
print_value(1.2f);
print_value(1.3f);
print_value(1.4f);
print_value(1.5f);
print_value(1.6f);
print_value(2.0f);
print_value(2.1f);
print_value(2.2f);
print_value(2.3f);
print_value(2.4f);
print_value(2.5f);
print_value(2.6f);
return Error;
} }
int test_Half1x16() int test_Half1x16()
{ {
int Error = 0; int Error = 0;
std::vector<float> Tests; std::vector<float> Tests;
Tests.push_back(0.0f); Tests.push_back(0.0f);
Tests.push_back(1.0f); Tests.push_back(1.0f);
Tests.push_back(-1.0f); Tests.push_back(-1.0f);
Tests.push_back(2.0f); Tests.push_back(2.0f);
Tests.push_back(-2.0f); Tests.push_back(-2.0f);
Tests.push_back(1.9f); Tests.push_back(1.9f);
for(std::size_t i = 0; i < Tests.size(); ++i) for(std::size_t i = 0; i < Tests.size(); ++i)
{ {
glm::uint32 p0 = glm::packHalf1x16(Tests[i]); glm::uint32 p0 = glm::packHalf1x16(Tests[i]);
float v0 = glm::unpackHalf1x16(p0); float v0 = glm::unpackHalf1x16(p0);
glm::uint32 p1 = glm::packHalf1x16(v0); glm::uint32 p1 = glm::packHalf1x16(v0);
float v1 = glm::unpackHalf1x16(p0); float v1 = glm::unpackHalf1x16(p0);
Error += (v0 == v1) ? 0 : 1; Error += (v0 == v1) ? 0 : 1;
} }
return Error; return Error;
} }
int test_Half4x16() int test_Half4x16()
{ {
int Error = 0; int Error = 0;
std::vector<glm::vec4> Tests; std::vector<glm::vec4> Tests;
Tests.push_back(glm::vec4(1.0)); Tests.push_back(glm::vec4(1.0));
Tests.push_back(glm::vec4(0.0)); Tests.push_back(glm::vec4(0.0));
Tests.push_back(glm::vec4(2.0)); Tests.push_back(glm::vec4(2.0));
Tests.push_back(glm::vec4(0.1)); Tests.push_back(glm::vec4(0.1));
Tests.push_back(glm::vec4(0.5)); Tests.push_back(glm::vec4(0.5));
Tests.push_back(glm::vec4(-0.9)); Tests.push_back(glm::vec4(-0.9));
for(std::size_t i = 0; i < Tests.size(); ++i) for(std::size_t i = 0; i < Tests.size(); ++i)
{ {
glm::uint64 p0 = glm::packHalf4x16(Tests[i]); glm::uint64 p0 = glm::packHalf4x16(Tests[i]);
glm::vec4 v0 = glm::unpackHalf4x16(p0); glm::vec4 v0 = glm::unpackHalf4x16(p0);
glm::uint64 p1 = glm::packHalf4x16(v0); glm::uint64 p1 = glm::packHalf4x16(v0);
glm::vec4 v1 = glm::unpackHalf4x16(p0); glm::vec4 v1 = glm::unpackHalf4x16(p0);
Error += glm::all(glm::equal(v0, v1)) ? 0 : 1; Error += glm::all(glm::equal(v0, v1)) ? 0 : 1;
} }
return Error; return Error;
} }
int test_I3x10_1x2() int test_I3x10_1x2()
{ {
int Error = 0; int Error = 0;
std::vector<glm::ivec4> Tests; std::vector<glm::ivec4> Tests;
Tests.push_back(glm::ivec4(0)); Tests.push_back(glm::ivec4(0));
Tests.push_back(glm::ivec4(1)); Tests.push_back(glm::ivec4(1));
Tests.push_back(glm::ivec4(-1)); Tests.push_back(glm::ivec4(-1));
Tests.push_back(glm::ivec4(2)); Tests.push_back(glm::ivec4(2));
Tests.push_back(glm::ivec4(-2)); Tests.push_back(glm::ivec4(-2));
Tests.push_back(glm::ivec4(3)); Tests.push_back(glm::ivec4(3));
for(std::size_t i = 0; i < Tests.size(); ++i) for(std::size_t i = 0; i < Tests.size(); ++i)
{ {
glm::uint32 p0 = glm::packI3x10_1x2(Tests[i]); glm::uint32 p0 = glm::packI3x10_1x2(Tests[i]);
glm::ivec4 v0 = glm::unpackI3x10_1x2(p0); glm::ivec4 v0 = glm::unpackI3x10_1x2(p0);
glm::uint32 p1 = glm::packI3x10_1x2(v0); glm::uint32 p1 = glm::packI3x10_1x2(v0);
glm::ivec4 v1 = glm::unpackI3x10_1x2(p0); glm::ivec4 v1 = glm::unpackI3x10_1x2(p0);
Error += glm::all(glm::equal(v0, v1)) ? 0 : 1; Error += glm::all(glm::equal(v0, v1)) ? 0 : 1;
} }
return Error; return Error;
} }
int test_U3x10_1x2() int test_U3x10_1x2()
{ {
int Error = 0; int Error = 0;
std::vector<glm::uvec4> Tests; std::vector<glm::uvec4> Tests;
Tests.push_back(glm::uvec4(0)); Tests.push_back(glm::uvec4(0));
Tests.push_back(glm::uvec4(1)); Tests.push_back(glm::uvec4(1));
Tests.push_back(glm::uvec4(2)); Tests.push_back(glm::uvec4(2));
Tests.push_back(glm::uvec4(3)); Tests.push_back(glm::uvec4(3));
Tests.push_back(glm::uvec4(4)); Tests.push_back(glm::uvec4(4));
Tests.push_back(glm::uvec4(5)); Tests.push_back(glm::uvec4(5));
for(std::size_t i = 0; i < Tests.size(); ++i) for(std::size_t i = 0; i < Tests.size(); ++i)
{ {
glm::uint32 p0 = glm::packU3x10_1x2(Tests[i]); glm::uint32 p0 = glm::packU3x10_1x2(Tests[i]);
glm::uvec4 v0 = glm::unpackU3x10_1x2(p0); glm::uvec4 v0 = glm::unpackU3x10_1x2(p0);
glm::uint32 p1 = glm::packU3x10_1x2(v0); glm::uint32 p1 = glm::packU3x10_1x2(v0);
glm::uvec4 v1 = glm::unpackU3x10_1x2(p0); glm::uvec4 v1 = glm::unpackU3x10_1x2(p0);
Error += glm::all(glm::equal(v0, v1)) ? 0 : 1; Error += glm::all(glm::equal(v0, v1)) ? 0 : 1;
} }
return Error; return Error;
} }
int test_Snorm3x10_1x2() int test_Snorm3x10_1x2()
{ {
int Error = 0; int Error = 0;
std::vector<glm::vec4> Tests; std::vector<glm::vec4> Tests;
Tests.push_back(glm::vec4(1.0)); Tests.push_back(glm::vec4(1.0));
Tests.push_back(glm::vec4(0.0)); Tests.push_back(glm::vec4(0.0));
Tests.push_back(glm::vec4(2.0)); Tests.push_back(glm::vec4(2.0));
Tests.push_back(glm::vec4(0.1)); Tests.push_back(glm::vec4(0.1));
Tests.push_back(glm::vec4(0.5)); Tests.push_back(glm::vec4(0.5));
Tests.push_back(glm::vec4(0.9)); Tests.push_back(glm::vec4(0.9));
for(std::size_t i = 0; i < Tests.size(); ++i) for(std::size_t i = 0; i < Tests.size(); ++i)
{ {
glm::uint32 p0 = glm::packSnorm3x10_1x2(Tests[i]); glm::uint32 p0 = glm::packSnorm3x10_1x2(Tests[i]);
glm::vec4 v0 = glm::unpackSnorm3x10_1x2(p0); glm::vec4 v0 = glm::unpackSnorm3x10_1x2(p0);
glm::uint32 p1 = glm::packSnorm3x10_1x2(v0); glm::uint32 p1 = glm::packSnorm3x10_1x2(v0);
glm::vec4 v1 = glm::unpackSnorm3x10_1x2(p0); glm::vec4 v1 = glm::unpackSnorm3x10_1x2(p0);
Error += glm::all(glm::equal(v0, v1)) ? 0 : 1; Error += glm::all(glm::equal(v0, v1)) ? 0 : 1;
} }
return Error; return Error;
} }
int test_Unorm3x10_1x2() int test_Unorm3x10_1x2()
{ {
int Error = 0; int Error = 0;
std::vector<glm::vec4> Tests; std::vector<glm::vec4> Tests;
Tests.push_back(glm::vec4(1.0)); Tests.push_back(glm::vec4(1.0));
Tests.push_back(glm::vec4(0.0)); Tests.push_back(glm::vec4(0.0));
Tests.push_back(glm::vec4(2.0)); Tests.push_back(glm::vec4(2.0));
Tests.push_back(glm::vec4(0.1)); Tests.push_back(glm::vec4(0.1));
Tests.push_back(glm::vec4(0.5)); Tests.push_back(glm::vec4(0.5));
Tests.push_back(glm::vec4(0.9)); Tests.push_back(glm::vec4(0.9));
for(std::size_t i = 0; i < Tests.size(); ++i) for(std::size_t i = 0; i < Tests.size(); ++i)
{ {
glm::uint32 p0 = glm::packSnorm3x10_1x2(Tests[i]); glm::uint32 p0 = glm::packSnorm3x10_1x2(Tests[i]);
glm::vec4 v0 = glm::unpackSnorm3x10_1x2(p0); glm::vec4 v0 = glm::unpackSnorm3x10_1x2(p0);
glm::uint32 p1 = glm::packSnorm3x10_1x2(v0); glm::uint32 p1 = glm::packSnorm3x10_1x2(v0);
glm::vec4 v1 = glm::unpackSnorm3x10_1x2(p0); glm::vec4 v1 = glm::unpackSnorm3x10_1x2(p0);
Error += glm::all(glm::equal(v0, v1)) ? 0 : 1; Error += glm::all(glm::equal(v0, v1)) ? 0 : 1;
} }
return Error; return Error;
} }
int test_F2x11_1x10() int test_F2x11_1x10()
{ {
int Error = 0; int Error = 0;
std::vector<glm::vec3> Tests; std::vector<glm::vec3> Tests;
Tests.push_back(glm::vec3(1.0)); Tests.push_back(glm::vec3(1.0));
Tests.push_back(glm::vec3(0.0)); Tests.push_back(glm::vec3(0.0));
Tests.push_back(glm::vec3(2.0)); Tests.push_back(glm::vec3(2.0));
Tests.push_back(glm::vec3(0.1)); Tests.push_back(glm::vec3(0.1));
Tests.push_back(glm::vec3(0.5)); Tests.push_back(glm::vec3(0.5));
Tests.push_back(glm::vec3(0.9)); Tests.push_back(glm::vec3(0.9));
for(std::size_t i = 0; i < Tests.size(); ++i) for(std::size_t i = 0; i < Tests.size(); ++i)
{ {
glm::uint32 p0 = glm::packF2x11_1x10(Tests[i]); glm::uint32 p0 = glm::packF2x11_1x10(Tests[i]);
glm::vec3 v0 = glm::unpackF2x11_1x10(p0); glm::vec3 v0 = glm::unpackF2x11_1x10(p0);
glm::uint32 p1 = glm::packF2x11_1x10(v0); glm::uint32 p1 = glm::packF2x11_1x10(v0);
glm::vec3 v1 = glm::unpackF2x11_1x10(p0); glm::vec3 v1 = glm::unpackF2x11_1x10(p0);
Error += glm::all(glm::equal(v0, v1)) ? 0 : 1; Error += glm::all(glm::equal(v0, v1)) ? 0 : 1;
} }
return Error; return Error;
} }
int main() int main()
{ {
int Error(0); int Error(0);
Error += test_F2x11_1x10(); Error += test_F2x11_1x10();
Error += test_Snorm3x10_1x2(); Error += test_Snorm3x10_1x2();
Error += test_Unorm3x10_1x2(); Error += test_Unorm3x10_1x2();
Error += test_I3x10_1x2(); Error += test_I3x10_1x2();
Error += test_U3x10_1x2(); Error += test_U3x10_1x2();
Error += test_Half1x16(); Error += test_Half1x16();
Error += test_U3x10_1x2(); Error += test_U3x10_1x2();
return Error; return Error;
} }