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

Fixed warnings with -Weverything

Browse Source
master
Christophe Riccio ago%!(EXTRA string=8 years)
parent 0f34103f4f
commit 32054a8fdf
3 changed files with 32 additions and 154 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. 30
      test/core/core_type_vec3.cpp
  2. 2
      test/core/core_type_vec4.cpp
  3. 154
      test/gtc/gtc_noise.cpp

30
test/core/core_type_vec3.cpp
Unescape View File

@ -258,10 +258,11 @@ int test_vec3_swizzle3_2()
{
int Error = 0;
glm::vec3 v(1, 2, 3);
glm::vec2 u;
# if(GLM_LANG & GLM_LANG_CXXMS_FLAG)
glm::vec3 v(1, 2, 3);
glm::vec2 u;
// Can not assign a vec3 swizzle to a vec2
//u = v.xyz; //Illegal
//u = v.rgb; //Illegal
@ -321,10 +322,10 @@ int test_vec3_swizzle3_3()
{
int Error = 0;
# if(GLM_LANG & GLM_LANG_CXXMS_FLAG)
glm::vec3 v(1, 2, 3);
glm::vec3 u;
# if(GLM_LANG & GLM_LANG_CXXMS_FLAG)
u = v; Error += (u.x == 1.0f && u.y == 2.0f && u.z == 3.0f) ? 0 : 1;
u = v.xyz; Error += (u.x == 1.0f && u.y == 2.0f && u.z == 3.0f) ? 0 : 1;
@ -348,12 +349,12 @@ int test_vec3_swizzle_operators()
{
int Error = 0;
glm::vec3 q, u, v;
u = glm::vec3(1, 2, 3);
v = glm::vec3(10, 20, 30);
glm::vec3 u = glm::vec3(1, 2, 3);
glm::vec3 v = glm::vec3(10, 20, 30);
# if(GLM_LANG & GLM_LANG_CXXMS_FLAG)
glm::vec3 q;
// Swizzle, swizzle binary operators
q = u.xyz + v.xyz; Error += (q == (u + v)) ? 0 : 1;
q = (u.zyx + v.zyx).zyx; Error += (q == (u + v)) ? 0 : 1;
@ -405,9 +406,8 @@ int test_vec3_swizzle_functions()
r = glm::dot(glm::vec2(a.xy()), glm::vec2(b.yy())); Error += (int(r) == 60) ? 0 : 1;
// vec3
glm::vec3 q, u, v;
u = glm::vec3(1, 2, 3);
v = glm::vec3(10, 20, 30);
glm::vec3 u = glm::vec3(1, 2, 3);
glm::vec3 v = glm::vec3(10, 20, 30);
r = glm::dot(u, v); Error += (int(r) == 140) ? 0 : 1;
r = glm::dot(u.xyz(), v.zyz()); Error += (int(r) == 160) ? 0 : 1;
r = glm::dot(u, v.zyx()); Error += (int(r) == 100) ? 0 : 1;
@ -415,9 +415,8 @@ int test_vec3_swizzle_functions()
r = glm::dot(u.xy(), v.xy()); Error += (int(r) == 50) ? 0 : 1;
// vec4
glm::vec4 s, t;
s = glm::vec4(1, 2, 3, 4);
t = glm::vec4(10, 20, 30, 40);
glm::vec4 s = glm::vec4(1, 2, 3, 4);
glm::vec4 t = glm::vec4(10, 20, 30, 40);
r = glm::dot(s, t); Error += (int(r) == 300) ? 0 : 1;
r = glm::dot(s.xyzw(), t.xyzw()); Error += (int(r) == 300) ? 0 : 1;
r = glm::dot(s.xyz(), t.xyz()); Error += (int(r) == 140) ? 0 : 1;
@ -483,9 +482,6 @@ int main()
{
int Error = 0;
glm::vec3 v;
assert(v.length() == 3);
Error += test_vec3_ctor();
Error += test_vec3_operators();
Error += test_vec3_size();

2
test/core/core_type_vec4.cpp
Unescape View File

@ -546,8 +546,6 @@ int main()
printf("GNI\n");
}
*/
glm::vec4 v;
assert(v.length() == 4);
# ifdef NDEBUG
std::size_t const Size(1000000);

154
test/gtc/gtc_noise.cpp
Unescape View File

@ -1,163 +1,47 @@
#define GLM_ENABLE_EXPERIMENTAL
#include <glm/gtc/noise.hpp>
#if GLM_LANG & GLM_LANG_CXX11_FLAG
#include <gli/gli.hpp>
std::size_t const Size = 64;
#include <glm/gtx/raw_data.hpp>
int test_simplex()
{
{
gli::texture2d Texture(gli::FORMAT_RGBA8_UNORM_PACK8, gli::texture2d::extent_type(Size), 1);
for(std::size_t y = 0; y < Size; ++y)
for(std::size_t x = 0; x < Size; ++x)
{
glm::u8vec4 Pixel(glm::byte(glm::abs(glm::simplex(glm::vec2(x / 64.f, y / 64.f))) * 255.f));
Texture.store(gli::extent2d(x, y), 0, Pixel);
}
gli::save(Texture, "texture_simplex2d_256.dds");
}
{
gli::texture2d Texture(gli::FORMAT_RGBA8_UNORM_PACK8, gli::texture2d::extent_type(Size), 1);
for(std::size_t y = 0; y < Size; ++y)
for(std::size_t x = 0; x < Size; ++x)
{
glm::u8vec4 Pixel(glm::byte(glm::abs(glm::simplex(glm::vec3(x / 64.f, y / 64.f, 0.5f))) * 255.f));
Texture.store(gli::extent2d(x, y), 0, Pixel);
}
gli::save(Texture, "texture_simplex3d_256.dds");
}
{
gli::texture2d Texture(gli::FORMAT_RGBA8_UNORM_PACK8, gli::texture2d::extent_type(Size), 1);
for(std::size_t y = 0; y < Size; ++y)
for(std::size_t x = 0; x < Size; ++x)
{
glm::u8vec4 Pixel(glm::byte(glm::abs(glm::simplex(glm::vec4(x / 64.f, y / 64.f, 0.5f, 0.5f))) * 255.f));
Texture.store(gli::extent2d(x, y), 0, Pixel);
}
int Error = 0;
gli::save(Texture, "texture_simplex4d_256.dds");
}
glm::u8vec4 const PixelSimplex2D(glm::byte(glm::abs(glm::simplex(glm::vec2(0.f, 0.f))) * 255.f));
glm::u8vec4 const PixelSimplex3D(glm::byte(glm::abs(glm::simplex(glm::vec3(0.f, 0.f, 0.f))) * 255.f));
glm::u8vec4 const PixelSimplex4D(glm::byte(glm::abs(glm::simplex(glm::vec4(0.f, 0.f, 0.f, 0.f))) * 255.f));
return 0;
return Error;
}
int test_perlin()
{
{
gli::texture2d Texture(gli::FORMAT_RGBA8_UNORM_PACK8, gli::texture2d::extent_type(Size), 1);
for(std::size_t y = 0; y < Size; ++y)
for(std::size_t x = 0; x < Size; ++x)
{
glm::u8vec4 Pixel(glm::byte(glm::abs(glm::perlin(glm::vec2(x / 64.f, y / 64.f))) * 255.f));
Texture.store(gli::extent2d(x, y), 0, Pixel);
}
gli::save(Texture, "texture_perlin2d_256.dds");
}
{
gli::texture2d Texture(gli::FORMAT_RGBA8_UNORM_PACK8, gli::texture2d::extent_type(Size), 1);
for(std::size_t y = 0; y < Size; ++y)
for(std::size_t x = 0; x < Size; ++x)
{
glm::u8vec4 Pixel(glm::byte(glm::abs(glm::perlin(glm::vec3(x / 64.f, y / 64.f, 0.5f))) * 255.f));
Texture.store(gli::extent2d(x, y), 0, Pixel);
}
gli::save(Texture, "texture_perlin3d_256.dds");
}
{
gli::texture2d Texture(gli::FORMAT_RGBA8_UNORM_PACK8, gli::texture2d::extent_type(Size), 1);
for(std::size_t y = 0; y < Size; ++y)
for(std::size_t x = 0; x < Size; ++x)
{
glm::u8vec4 Pixel(glm::byte(glm::abs(glm::perlin(glm::vec4(x / 64.f, y / 64.f, 0.5f, 0.5f))) * 255.f));
Texture.store(gli::extent2d(x, y), 0, Pixel);
}
int Error = 0;
gli::save(Texture, "texture_perlin4d_256.dds");
}
glm::u8vec4 const PixelPerlin2D(glm::byte(glm::abs(glm::perlin(glm::vec2(0.f, 0.f))) * 255.f));
glm::u8vec4 const PixelPerlin3D(glm::byte(glm::abs(glm::perlin(glm::vec3(0.f, 0.f, 0.f))) * 255.f));
glm::u8vec4 const PixelPerlin4D(glm::byte(glm::abs(glm::perlin(glm::vec4(0.f, 0.f, 0.f, 0.f))) * 255.f));
return 0;
return Error;
}
int test_perlin_pedioric()
{
{
gli::texture2d Texture(gli::FORMAT_RGBA8_UNORM_PACK8, gli::texture2d::extent_type(Size), 1);
for(std::size_t y = 0; y < Size; ++y)
for(std::size_t x = 0; x < Size; ++x)
{
glm::u8vec4 Pixel(glm::byte(glm::abs(glm::perlin(glm::vec2(x / 64.f, y / 64.f), glm::vec2(2.0f))) * 255.f));
Texture.store(gli::extent2d(x, y), 0, Pixel);
}
gli::save(Texture, "texture_perlin_pedioric_2d_256.dds");
}
{
gli::texture2d Texture(gli::FORMAT_RGBA8_UNORM_PACK8, gli::texture2d::extent_type(Size), 1);
for(std::size_t y = 0; y < Size; ++y)
for(std::size_t x = 0; x < Size; ++x)
{
glm::u8vec4 Pixel(glm::byte(glm::abs(glm::perlin(glm::vec3(x / 64.f, y / 64.f, 0.5f), glm::vec3(2.0f))) * 255.f));
Texture.store(gli::extent2d(x, y), 0, Pixel);
}
gli::save(Texture, "texture_perlin_pedioric_3d_256.dds");
}
{
gli::texture2d Texture(gli::FORMAT_RGBA8_UNORM_PACK8, gli::texture2d::extent_type(Size), 1);
for(std::size_t y = 0; y < Size; ++y)
for(std::size_t x = 0; x < Size; ++x)
{
glm::u8vec4 Pixel(glm::byte(glm::abs(glm::perlin(glm::vec4(x / 64.f, y / 64.f, 0.5f, 0.5f), glm::vec4(2.0f))) * 255.f));
Texture.store(gli::extent2d(x, y), 0, Pixel);
}
int Error = 0;
gli::save(Texture, "texture_perlin_pedioric_4d_256.dds");
}
glm::u8vec4 const PixelPeriodic2D(glm::byte(glm::abs(glm::perlin(glm::vec2(0.f, 0.f), glm::vec2(2.0f))) * 255.f));
glm::u8vec4 const PixelPeriodic3D(glm::byte(glm::abs(glm::perlin(glm::vec3(0.f, 0.f, 0.f), glm::vec3(2.0f))) * 255.f));
glm::u8vec4 const PixelPeriodic4D(glm::byte(glm::abs(glm::perlin(glm::vec4(0.f, 0.f, 0.f, 0.f), glm::vec4(2.0f))) * 255.f));
return 0;
return Error;
}
#endif//GLM_LANG & GLM_LANG_CXX11_FLAG
int main()
{
int Error = 0;
# if GLM_LANG & GLM_LANG_CXX11_FLAG
Error += test_simplex();
Error += test_perlin();
Error += test_perlin_pedioric();
# endif
Error += test_simplex();
Error += test_perlin();
Error += test_perlin_pedioric();
return Error;
}

Write Preview
Loading…
Cancel
Save