first commit
This commit is contained in:
@@ -0,0 +1,50 @@
|
||||
glmCreateTestGTC(gtx)
|
||||
glmCreateTestGTC(gtx_associated_min_max)
|
||||
glmCreateTestGTC(gtx_closest_point)
|
||||
glmCreateTestGTC(gtx_color_space_YCoCg)
|
||||
glmCreateTestGTC(gtx_color_space)
|
||||
glmCreateTestGTC(gtx_common)
|
||||
glmCreateTestGTC(gtx_compatibility)
|
||||
glmCreateTestGTC(gtx_component_wise)
|
||||
glmCreateTestGTC(gtx_euler_angle)
|
||||
glmCreateTestGTC(gtx_extend)
|
||||
glmCreateTestGTC(gtx_extended_min_max)
|
||||
glmCreateTestGTC(gtx_fast_exponential)
|
||||
glmCreateTestGTC(gtx_fast_square_root)
|
||||
glmCreateTestGTC(gtx_fast_trigonometry)
|
||||
glmCreateTestGTC(gtx_gradient_paint)
|
||||
glmCreateTestGTC(gtx_handed_coordinate_space)
|
||||
glmCreateTestGTC(gtx_integer)
|
||||
glmCreateTestGTC(gtx_intersect)
|
||||
glmCreateTestGTC(gtx_io)
|
||||
glmCreateTestGTC(gtx_log_base)
|
||||
glmCreateTestGTC(gtx_matrix_cross_product)
|
||||
glmCreateTestGTC(gtx_matrix_decompose)
|
||||
glmCreateTestGTC(gtx_matrix_interpolation)
|
||||
glmCreateTestGTC(gtx_matrix_major_storage)
|
||||
glmCreateTestGTC(gtx_matrix_operation)
|
||||
glmCreateTestGTC(gtx_matrix_query)
|
||||
glmCreateTestGTC(gtx_matrix_transform_2d)
|
||||
glmCreateTestGTC(gtx_norm)
|
||||
glmCreateTestGTC(gtx_normal)
|
||||
glmCreateTestGTC(gtx_normalize_dot)
|
||||
glmCreateTestGTC(gtx_number_precision)
|
||||
glmCreateTestGTC(gtx_orthonormalize)
|
||||
glmCreateTestGTC(gtx_optimum_pow)
|
||||
glmCreateTestGTC(gtx_perpendicular)
|
||||
glmCreateTestGTC(gtx_polar_coordinates)
|
||||
glmCreateTestGTC(gtx_projection)
|
||||
glmCreateTestGTC(gtx_quaternion)
|
||||
glmCreateTestGTC(gtx_dual_quaternion)
|
||||
glmCreateTestGTC(gtx_range)
|
||||
glmCreateTestGTC(gtx_rotate_normalized_axis)
|
||||
glmCreateTestGTC(gtx_rotate_vector)
|
||||
glmCreateTestGTC(gtx_scalar_multiplication)
|
||||
glmCreateTestGTC(gtx_scalar_relational)
|
||||
glmCreateTestGTC(gtx_spline)
|
||||
glmCreateTestGTC(gtx_string_cast)
|
||||
glmCreateTestGTC(gtx_type_aligned)
|
||||
glmCreateTestGTC(gtx_type_trait)
|
||||
glmCreateTestGTC(gtx_vector_angle)
|
||||
glmCreateTestGTC(gtx_vector_query)
|
||||
glmCreateTestGTC(gtx_wrap)
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <glm/ext.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
#include <glm/gtc/type_precision.hpp>
|
||||
#include <glm/gtx/associated_min_max.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <glm/gtx/closest_point.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
#include <glm/gtx/color_space.hpp>
|
||||
|
||||
int test_saturation()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
glm::vec4 Color = glm::saturation(1.0f, glm::vec4(1.0, 0.5, 0.0, 1.0));
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += test_saturation();
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <glm/gtx/color_space_YCoCg.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,127 @@
|
||||
#include <glm/gtx/common.hpp>
|
||||
#include <glm/gtc/integer.hpp>
|
||||
#include <glm/gtc/epsilon.hpp>
|
||||
#include <glm/vector_relational.hpp>
|
||||
#include <glm/common.hpp>
|
||||
|
||||
namespace fmod_
|
||||
{
|
||||
template <typename genType>
|
||||
GLM_FUNC_QUALIFIER genType modTrunc(genType a, genType b)
|
||||
{
|
||||
return a - b * glm::trunc(a / b);
|
||||
}
|
||||
|
||||
int test()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
{
|
||||
float A0(3.0);
|
||||
float B0(2.0f);
|
||||
float C0 = glm::fmod(A0, B0);
|
||||
|
||||
Error += glm::abs(C0 - 1.0f) < 0.00001f ? 0 : 1;
|
||||
|
||||
glm::vec4 A1(3.0);
|
||||
float B1(2.0f);
|
||||
glm::vec4 C1 = glm::fmod(A1, B1);
|
||||
|
||||
Error += glm::all(glm::epsilonEqual(C1, glm::vec4(1.0f), 0.00001f)) ? 0 : 1;
|
||||
|
||||
glm::vec4 A2(3.0);
|
||||
glm::vec4 B2(2.0f);
|
||||
glm::vec4 C2 = glm::fmod(A2, B2);
|
||||
|
||||
Error += glm::all(glm::epsilonEqual(C2, glm::vec4(1.0f), 0.00001f)) ? 0 : 1;
|
||||
|
||||
glm::ivec4 A3(3);
|
||||
int B3(2);
|
||||
glm::ivec4 C3 = glm::fmod(A3, B3);
|
||||
|
||||
Error += glm::all(glm::equal(C3, glm::ivec4(1))) ? 0 : 1;
|
||||
|
||||
glm::ivec4 A4(3);
|
||||
glm::ivec4 B4(2);
|
||||
glm::ivec4 C4 = glm::fmod(A4, B4);
|
||||
|
||||
Error += glm::all(glm::equal(C4, glm::ivec4(1))) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
float A0(22.0);
|
||||
float B0(-10.0f);
|
||||
float C0 = glm::fmod(A0, B0);
|
||||
|
||||
Error += glm::abs(C0 - 2.0f) < 0.00001f ? 0 : 1;
|
||||
|
||||
glm::vec4 A1(22.0);
|
||||
float B1(-10.0f);
|
||||
glm::vec4 C1 = glm::fmod(A1, B1);
|
||||
|
||||
Error += glm::all(glm::epsilonEqual(C1, glm::vec4(2.0f), 0.00001f)) ? 0 : 1;
|
||||
|
||||
glm::vec4 A2(22.0);
|
||||
glm::vec4 B2(-10.0f);
|
||||
glm::vec4 C2 = glm::fmod(A2, B2);
|
||||
|
||||
Error += glm::all(glm::epsilonEqual(C2, glm::vec4(2.0f), 0.00001f)) ? 0 : 1;
|
||||
|
||||
glm::ivec4 A3(22);
|
||||
int B3(-10);
|
||||
glm::ivec4 C3 = glm::fmod(A3, B3);
|
||||
|
||||
Error += glm::all(glm::equal(C3, glm::ivec4(2))) ? 0 : 1;
|
||||
|
||||
glm::ivec4 A4(22);
|
||||
glm::ivec4 B4(-10);
|
||||
glm::ivec4 C4 = glm::fmod(A4, B4);
|
||||
|
||||
Error += glm::all(glm::equal(C4, glm::ivec4(2))) ? 0 : 1;
|
||||
}
|
||||
|
||||
// http://stackoverflow.com/questions/7610631/glsl-mod-vs-hlsl-fmod
|
||||
{
|
||||
for (float y = -10.0f; y < 10.0f; y += 0.1f)
|
||||
for (float x = -10.0f; x < 10.0f; x += 0.1f)
|
||||
{
|
||||
float const A(std::fmod(x, y));
|
||||
//float const B(std::remainder(x, y));
|
||||
float const C(glm::fmod(x, y));
|
||||
float const D(modTrunc(x, y));
|
||||
|
||||
//Error += glm::epsilonEqual(A, B, 0.0001f) ? 0 : 1;
|
||||
//assert(!Error);
|
||||
Error += glm::epsilonEqual(A, C, 0.0001f) ? 0 : 1;
|
||||
assert(!Error);
|
||||
Error += glm::epsilonEqual(A, D, 0.00001f) ? 0 : 1;
|
||||
assert(!Error);
|
||||
}
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
}//namespace fmod_
|
||||
|
||||
int test_isdenormal()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
bool A = glm::isdenormal(1.0f);
|
||||
glm::bvec1 B = glm::isdenormal(glm::vec1(1.0f));
|
||||
glm::bvec2 C = glm::isdenormal(glm::vec2(1.0f));
|
||||
glm::bvec3 D = glm::isdenormal(glm::vec3(1.0f));
|
||||
glm::bvec4 E = glm::isdenormal(glm::vec4(1.0f));
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
Error += test_isdenormal();
|
||||
Error += ::fmod_::test();
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
#include <glm/gtx/compatibility.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += glm::isfinite(1.0f) ? 0 : 1;
|
||||
Error += glm::isfinite(1.0) ? 0 : 1;
|
||||
Error += glm::isfinite(-1.0f) ? 0 : 1;
|
||||
Error += glm::isfinite(-1.0) ? 0 : 1;
|
||||
|
||||
Error += glm::all(glm::isfinite(glm::vec4(1.0f))) ? 0 : 1;
|
||||
Error += glm::all(glm::isfinite(glm::dvec4(1.0))) ? 0 : 1;
|
||||
Error += glm::all(glm::isfinite(glm::vec4(-1.0f))) ? 0 : 1;
|
||||
Error += glm::all(glm::isfinite(glm::dvec4(-1.0))) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,115 @@
|
||||
#include <glm/gtx/component_wise.hpp>
|
||||
#include <glm/gtc/type_precision.hpp>
|
||||
#include <glm/gtc/epsilon.hpp>
|
||||
#include <glm/gtc/constants.hpp>
|
||||
#include <limits>
|
||||
|
||||
namespace compNormalize
|
||||
{
|
||||
int run()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
{
|
||||
glm::vec4 const A = glm::compNormalize<float>(glm::u8vec4(0, 127, 128, 255));
|
||||
|
||||
Error += glm::epsilonEqual(A.x, 0.0f, glm::epsilon<float>()) ? 0 : 1;
|
||||
Error += A.y < 0.5f ? 0 : 1;
|
||||
Error += A.z > 0.5f ? 0 : 1;
|
||||
Error += glm::epsilonEqual(A.w, 1.0f, glm::epsilon<float>()) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::vec4 const A = glm::compNormalize<float>(glm::i8vec4(-128, -1, 0, 127));
|
||||
|
||||
Error += glm::epsilonEqual(A.x,-1.0f, glm::epsilon<float>()) ? 0 : 1;
|
||||
Error += A.y < 0.0f ? 0 : 1;
|
||||
Error += A.z > 0.0f ? 0 : 1;
|
||||
Error += glm::epsilonEqual(A.w, 1.0f, glm::epsilon<float>()) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::vec4 const A = glm::compNormalize<float>(glm::u16vec4(
|
||||
std::numeric_limits<glm::u16>::min(),
|
||||
(std::numeric_limits<glm::u16>::max() >> 1) + 0,
|
||||
(std::numeric_limits<glm::u16>::max() >> 1) + 1,
|
||||
std::numeric_limits<glm::u16>::max()));
|
||||
|
||||
Error += glm::epsilonEqual(A.x, 0.0f, glm::epsilon<float>()) ? 0 : 1;
|
||||
Error += A.y < 0.5f ? 0 : 1;
|
||||
Error += A.z > 0.5f ? 0 : 1;
|
||||
Error += glm::epsilonEqual(A.w, 1.0f, glm::epsilon<float>()) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::vec4 const A = glm::compNormalize<float>(glm::i16vec4(
|
||||
std::numeric_limits<glm::i16>::min(),
|
||||
static_cast<glm::i16>(-1),
|
||||
static_cast<glm::i16>(0),
|
||||
std::numeric_limits<glm::i16>::max()));
|
||||
|
||||
Error += glm::epsilonEqual(A.x,-1.0f, glm::epsilon<float>()) ? 0 : 1;
|
||||
Error += A.y < 0.0f ? 0 : 1;
|
||||
Error += A.z > 0.0f ? 0 : 1;
|
||||
Error += glm::epsilonEqual(A.w, 1.0f, glm::epsilon<float>()) ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
}//namespace compNormalize
|
||||
|
||||
namespace compScale
|
||||
{
|
||||
int run()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
{
|
||||
glm::u8vec4 const A = glm::compScale<glm::u8>(glm::vec4(0.0f, 0.2f, 0.5f, 1.0f));
|
||||
|
||||
Error += A.x == std::numeric_limits<glm::u8>::min() ? 0 : 1;
|
||||
Error += A.y < (std::numeric_limits<glm::u8>::max() >> 2) ? 0 : 1;
|
||||
Error += A.z == 127 ? 0 : 1;
|
||||
Error += A.w == 255 ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::i8vec4 const A = glm::compScale<glm::i8>(glm::vec4(0.0f,-1.0f, 0.5f, 1.0f));
|
||||
|
||||
Error += A.x == 0 ? 0 : 1;
|
||||
Error += A.y == -128 ? 0 : 1;
|
||||
Error += A.z == 63 ? 0 : 1;
|
||||
Error += A.w == 127 ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::u16vec4 const A = glm::compScale<glm::u16>(glm::vec4(0.0f, 0.2f, 0.5f, 1.0f));
|
||||
|
||||
Error += A.x == std::numeric_limits<glm::u16>::min() ? 0 : 1;
|
||||
Error += A.y < (std::numeric_limits<glm::u16>::max() >> 2) ? 0 : 1;
|
||||
Error += A.z == 32767 ? 0 : 1;
|
||||
Error += A.w == 65535 ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::i16vec4 const A = glm::compScale<glm::i16>(glm::vec4(0.0f,-1.0f, 0.5f, 1.0f));
|
||||
|
||||
Error += A.x == 0 ? 0 : 1;
|
||||
Error += A.y == -32768 ? 0 : 1;
|
||||
Error += A.z == 16383 ? 0 : 1;
|
||||
Error += A.w == 32767 ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
}// compScale
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += compNormalize::run();
|
||||
Error += compScale::run();
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,203 @@
|
||||
#include <glm/gtx/dual_quaternion.hpp>
|
||||
#include <glm/gtc/matrix_transform.hpp>
|
||||
#include <glm/gtc/epsilon.hpp>
|
||||
#include <glm/gtx/euler_angles.hpp>
|
||||
#include <glm/vector_relational.hpp>
|
||||
#if GLM_HAS_TRIVIAL_QUERIES
|
||||
# include <type_traits>
|
||||
#endif
|
||||
|
||||
int myrand()
|
||||
{
|
||||
static int holdrand = 1;
|
||||
return (((holdrand = holdrand * 214013L + 2531011L) >> 16) & 0x7fff);
|
||||
}
|
||||
|
||||
float myfrand() // returns values from -1 to 1 inclusive
|
||||
{
|
||||
return float(double(myrand()) / double( 0x7ffff )) * 2.0f - 1.0f;
|
||||
}
|
||||
|
||||
int test_dquat_type()
|
||||
{
|
||||
glm::dvec3 vA;
|
||||
glm::dquat dqA,dqB;
|
||||
glm::ddualquat C(dqA,dqB);
|
||||
glm::ddualquat B(dqA);
|
||||
glm::ddualquat D(dqA,vA);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int test_scalars()
|
||||
{
|
||||
float const Epsilon = 0.0001f;
|
||||
|
||||
int Error(0);
|
||||
|
||||
glm::quat src_q1 = glm::quat(1.0f,2.0f,3.0f,4.0f);
|
||||
glm::quat src_q2 = glm::quat(5.0f,6.0f,7.0f,8.0f);
|
||||
glm::dualquat src1(src_q1,src_q2);
|
||||
|
||||
{
|
||||
glm::dualquat dst1 = src1 * 2.0f;
|
||||
glm::dualquat dst2 = 2.0f * src1;
|
||||
glm::dualquat dst3 = src1;
|
||||
dst3 *= 2.0f;
|
||||
glm::dualquat dstCmp(src_q1 * 2.0f,src_q2 * 2.0f);
|
||||
Error += glm::all(glm::epsilonEqual(dst1.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst1.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(dst2.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst2.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(dst3.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst3.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::dualquat dst1 = src1 / 2.0f;
|
||||
glm::dualquat dst2 = src1;
|
||||
dst2 /= 2.0f;
|
||||
glm::dualquat dstCmp(src_q1 / 2.0f,src_q2 / 2.0f);
|
||||
Error += glm::all(glm::epsilonEqual(dst1.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst1.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(dst2.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst2.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
|
||||
}
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_inverse()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
float const Epsilon = 0.0001f;
|
||||
|
||||
glm::dualquat dqid;
|
||||
glm::mat4x4 mid(1.0f);
|
||||
|
||||
for (int j = 0; j < 100; ++j)
|
||||
{
|
||||
glm::mat4x4 rot = glm::yawPitchRoll(myfrand() * 360.0f, myfrand() * 360.0f, myfrand() * 360.0f);
|
||||
glm::vec3 vt = glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f);
|
||||
|
||||
glm::mat4x4 m = glm::translate(mid, vt) * rot;
|
||||
|
||||
glm::quat qr = glm::quat_cast(m);
|
||||
|
||||
glm::dualquat dq(qr);
|
||||
|
||||
glm::dualquat invdq = glm::inverse(dq);
|
||||
|
||||
glm::dualquat r1 = invdq * dq;
|
||||
glm::dualquat r2 = dq * invdq;
|
||||
|
||||
Error += glm::all(glm::epsilonEqual(r1.real, dqid.real, Epsilon)) && glm::all(glm::epsilonEqual(r1.dual, dqid.dual, Epsilon)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(r2.real, dqid.real, Epsilon)) && glm::all(glm::epsilonEqual(r2.dual, dqid.dual, Epsilon)) ? 0 : 1;
|
||||
|
||||
// testing commutative property
|
||||
glm::dualquat r ( glm::quat( myfrand() * glm::pi<float>() * 2.0f, myfrand(), myfrand(), myfrand() ),
|
||||
glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f) );
|
||||
glm::dualquat riq = (r * invdq) * dq;
|
||||
glm::dualquat rqi = (r * dq) * invdq;
|
||||
|
||||
Error += glm::all(glm::epsilonEqual(riq.real, rqi.real, Epsilon)) && glm::all(glm::epsilonEqual(riq.dual, rqi.dual, Epsilon)) ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_mul()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
float const Epsilon = 0.0001f;
|
||||
|
||||
glm::mat4x4 mid(1.0f);
|
||||
|
||||
for (int j = 0; j < 100; ++j)
|
||||
{
|
||||
// generate random rotations and translations and compare transformed by matrix and dualquats random points
|
||||
glm::vec3 vt1 = glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f);
|
||||
glm::vec3 vt2 = glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f);
|
||||
|
||||
glm::mat4x4 rot1 = glm::yawPitchRoll(myfrand() * 360.0f, myfrand() * 360.0f, myfrand() * 360.0f);
|
||||
glm::mat4x4 rot2 = glm::yawPitchRoll(myfrand() * 360.0f, myfrand() * 360.0f, myfrand() * 360.0f);
|
||||
glm::mat4x4 m1 = glm::translate(mid, vt1) * rot1;
|
||||
glm::mat4x4 m2 = glm::translate(mid, vt2) * rot2;
|
||||
glm::mat4x4 m3 = m2 * m1;
|
||||
glm::mat4x4 m4 = m1 * m2;
|
||||
|
||||
glm::quat qrot1 = glm::quat_cast(rot1);
|
||||
glm::quat qrot2 = glm::quat_cast(rot2);
|
||||
|
||||
glm::dualquat dq1 = glm::dualquat(qrot1,vt1);
|
||||
glm::dualquat dq2 = glm::dualquat(qrot2,vt2);
|
||||
glm::dualquat dq3 = dq2 * dq1;
|
||||
glm::dualquat dq4 = dq1 * dq2;
|
||||
|
||||
for (int i = 0; i < 100; ++i)
|
||||
{
|
||||
glm::vec4 src_pt = glm::vec4(myfrand() * 4.0f, myfrand() * 5.0f, myfrand() * 3.0f,1.0f);
|
||||
// test both multiplication orders
|
||||
glm::vec4 dst_pt_m3 = m3 * src_pt;
|
||||
glm::vec4 dst_pt_dq3 = dq3 * src_pt;
|
||||
|
||||
glm::vec4 dst_pt_m3_i = glm::inverse(m3) * src_pt;
|
||||
glm::vec4 dst_pt_dq3_i = src_pt * dq3;
|
||||
|
||||
glm::vec4 dst_pt_m4 = m4 * src_pt;
|
||||
glm::vec4 dst_pt_dq4 = dq4 * src_pt;
|
||||
|
||||
glm::vec4 dst_pt_m4_i = glm::inverse(m4) * src_pt;
|
||||
glm::vec4 dst_pt_dq4_i = src_pt * dq4;
|
||||
|
||||
Error += glm::all(glm::epsilonEqual(dst_pt_m3, dst_pt_dq3, Epsilon)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(dst_pt_m4, dst_pt_dq4, Epsilon)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(dst_pt_m3_i, dst_pt_dq3_i, Epsilon)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(dst_pt_m4_i, dst_pt_dq4_i, Epsilon)) ? 0 : 1;
|
||||
}
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_dual_quat_ctr()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
# if GLM_HAS_TRIVIAL_QUERIES
|
||||
// Error += std::is_trivially_default_constructible<glm::dualquat>::value ? 0 : 1;
|
||||
// Error += std::is_trivially_default_constructible<glm::ddualquat>::value ? 0 : 1;
|
||||
// Error += std::is_trivially_copy_assignable<glm::dualquat>::value ? 0 : 1;
|
||||
// Error += std::is_trivially_copy_assignable<glm::ddualquat>::value ? 0 : 1;
|
||||
Error += std::is_trivially_copyable<glm::dualquat>::value ? 0 : 1;
|
||||
Error += std::is_trivially_copyable<glm::ddualquat>::value ? 0 : 1;
|
||||
|
||||
Error += std::is_copy_constructible<glm::dualquat>::value ? 0 : 1;
|
||||
Error += std::is_copy_constructible<glm::ddualquat>::value ? 0 : 1;
|
||||
# endif
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_size()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
Error += 32 == sizeof(glm::dualquat) ? 0 : 1;
|
||||
Error += 64 == sizeof(glm::ddualquat) ? 0 : 1;
|
||||
Error += glm::dualquat().length() == 2 ? 0 : 1;
|
||||
Error += glm::ddualquat().length() == 2 ? 0 : 1;
|
||||
Error += glm::dualquat::length() == 2 ? 0 : 1;
|
||||
Error += glm::ddualquat::length() == 2 ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
Error += test_dual_quat_ctr();
|
||||
Error += test_dquat_type();
|
||||
Error += test_scalars();
|
||||
Error += test_inverse();
|
||||
Error += test_mul();
|
||||
Error += test_size();
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,328 @@
|
||||
// Code sample from Filippo Ramaciotti
|
||||
|
||||
#include <glm/gtc/matrix_transform.hpp>
|
||||
#include <glm/gtc/epsilon.hpp>
|
||||
#include <glm/gtx/string_cast.hpp>
|
||||
#include <glm/gtx/euler_angles.hpp>
|
||||
#include <cstdio>
|
||||
|
||||
namespace test_eulerAngleX
|
||||
{
|
||||
int test()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
float const Angle(glm::pi<float>() * 0.5f);
|
||||
glm::vec3 const X(1.0f, 0.0f, 0.0f);
|
||||
|
||||
glm::vec4 const Y(0.0f, 1.0f, 0.0f, 1.0f);
|
||||
glm::vec4 const Y1 = glm::rotate(glm::mat4(1.0f), Angle, X) * Y;
|
||||
glm::vec4 const Y2 = glm::eulerAngleX(Angle) * Y;
|
||||
glm::vec4 const Y3 = glm::eulerAngleXY(Angle, 0.0f) * Y;
|
||||
glm::vec4 const Y4 = glm::eulerAngleYX(0.0f, Angle) * Y;
|
||||
glm::vec4 const Y5 = glm::eulerAngleXZ(Angle, 0.0f) * Y;
|
||||
glm::vec4 const Y6 = glm::eulerAngleZX(0.0f, Angle) * Y;
|
||||
glm::vec4 const Y7 = glm::eulerAngleYXZ(0.0f, Angle, 0.0f) * Y;
|
||||
Error += glm::all(glm::epsilonEqual(Y1, Y2, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(Y1, Y3, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(Y1, Y4, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(Y1, Y5, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(Y1, Y6, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(Y1, Y7, 0.00001f)) ? 0 : 1;
|
||||
|
||||
glm::vec4 const Z(0.0f, 0.0f, 1.0f, 1.0f);
|
||||
glm::vec4 const Z1 = glm::rotate(glm::mat4(1.0f), Angle, X) * Z;
|
||||
glm::vec4 const Z2 = glm::eulerAngleX(Angle) * Z;
|
||||
glm::vec4 const Z3 = glm::eulerAngleXY(Angle, 0.0f) * Z;
|
||||
glm::vec4 const Z4 = glm::eulerAngleYX(0.0f, Angle) * Z;
|
||||
glm::vec4 const Z5 = glm::eulerAngleXZ(Angle, 0.0f) * Z;
|
||||
glm::vec4 const Z6 = glm::eulerAngleZX(0.0f, Angle) * Z;
|
||||
glm::vec4 const Z7 = glm::eulerAngleYXZ(0.0f, Angle, 0.0f) * Z;
|
||||
Error += glm::all(glm::epsilonEqual(Z1, Z2, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(Z1, Z3, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(Z1, Z4, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(Z1, Z5, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(Z1, Z6, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(Z1, Z7, 0.00001f)) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
}//namespace test_eulerAngleX
|
||||
|
||||
namespace test_eulerAngleY
|
||||
{
|
||||
int test()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
float const Angle(glm::pi<float>() * 0.5f);
|
||||
glm::vec3 const Y(0.0f, 1.0f, 0.0f);
|
||||
|
||||
glm::vec4 const X(1.0f, 0.0f, 0.0f, 1.0f);
|
||||
glm::vec4 const X1 = glm::rotate(glm::mat4(1.0f), Angle, Y) * X;
|
||||
glm::vec4 const X2 = glm::eulerAngleY(Angle) * X;
|
||||
glm::vec4 const X3 = glm::eulerAngleYX(Angle, 0.0f) * X;
|
||||
glm::vec4 const X4 = glm::eulerAngleXY(0.0f, Angle) * X;
|
||||
glm::vec4 const X5 = glm::eulerAngleYZ(Angle, 0.0f) * X;
|
||||
glm::vec4 const X6 = glm::eulerAngleZY(0.0f, Angle) * X;
|
||||
glm::vec4 const X7 = glm::eulerAngleYXZ(Angle, 0.0f, 0.0f) * X;
|
||||
Error += glm::all(glm::epsilonEqual(X1, X2, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(X1, X3, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(X1, X4, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(X1, X5, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(X1, X6, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(X1, X7, 0.00001f)) ? 0 : 1;
|
||||
|
||||
glm::vec4 const Z(0.0f, 0.0f, 1.0f, 1.0f);
|
||||
glm::vec4 const Z1 = glm::eulerAngleY(Angle) * Z;
|
||||
glm::vec4 const Z2 = glm::rotate(glm::mat4(1.0f), Angle, Y) * Z;
|
||||
glm::vec4 const Z3 = glm::eulerAngleYX(Angle, 0.0f) * Z;
|
||||
glm::vec4 const Z4 = glm::eulerAngleXY(0.0f, Angle) * Z;
|
||||
glm::vec4 const Z5 = glm::eulerAngleYZ(Angle, 0.0f) * Z;
|
||||
glm::vec4 const Z6 = glm::eulerAngleZY(0.0f, Angle) * Z;
|
||||
glm::vec4 const Z7 = glm::eulerAngleYXZ(Angle, 0.0f, 0.0f) * Z;
|
||||
Error += glm::all(glm::epsilonEqual(Z1, Z2, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(Z1, Z3, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(Z1, Z4, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(Z1, Z5, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(Z1, Z6, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(Z1, Z7, 0.00001f)) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
}//namespace test_eulerAngleY
|
||||
|
||||
namespace test_eulerAngleZ
|
||||
{
|
||||
int test()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
float const Angle(glm::pi<float>() * 0.5f);
|
||||
glm::vec3 const Z(0.0f, 0.0f, 1.0f);
|
||||
|
||||
glm::vec4 const X(1.0f, 0.0f, 0.0f, 1.0f);
|
||||
glm::vec4 const X1 = glm::rotate(glm::mat4(1.0f), Angle, Z) * X;
|
||||
glm::vec4 const X2 = glm::eulerAngleZ(Angle) * X;
|
||||
glm::vec4 const X3 = glm::eulerAngleZX(Angle, 0.0f) * X;
|
||||
glm::vec4 const X4 = glm::eulerAngleXZ(0.0f, Angle) * X;
|
||||
glm::vec4 const X5 = glm::eulerAngleZY(Angle, 0.0f) * X;
|
||||
glm::vec4 const X6 = glm::eulerAngleYZ(0.0f, Angle) * X;
|
||||
glm::vec4 const X7 = glm::eulerAngleYXZ(0.0f, 0.0f, Angle) * X;
|
||||
Error += glm::all(glm::epsilonEqual(X1, X2, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(X1, X3, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(X1, X4, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(X1, X5, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(X1, X6, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(X1, X7, 0.00001f)) ? 0 : 1;
|
||||
|
||||
glm::vec4 const Y(1.0f, 0.0f, 0.0f, 1.0f);
|
||||
glm::vec4 const Z1 = glm::rotate(glm::mat4(1.0f), Angle, Z) * Y;
|
||||
glm::vec4 const Z2 = glm::eulerAngleZ(Angle) * Y;
|
||||
glm::vec4 const Z3 = glm::eulerAngleZX(Angle, 0.0f) * Y;
|
||||
glm::vec4 const Z4 = glm::eulerAngleXZ(0.0f, Angle) * Y;
|
||||
glm::vec4 const Z5 = glm::eulerAngleZY(Angle, 0.0f) * Y;
|
||||
glm::vec4 const Z6 = glm::eulerAngleYZ(0.0f, Angle) * Y;
|
||||
glm::vec4 const Z7 = glm::eulerAngleYXZ(0.0f, 0.0f, Angle) * Y;
|
||||
Error += glm::all(glm::epsilonEqual(Z1, Z2, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(Z1, Z3, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(Z1, Z4, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(Z1, Z5, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(Z1, Z6, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(Z1, Z7, 0.00001f)) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
}//namespace test_eulerAngleZ
|
||||
|
||||
namespace test_eulerAngleXY
|
||||
{
|
||||
int test()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::vec4 const V(1.0f);
|
||||
|
||||
float const AngleX(glm::pi<float>() * 0.5f);
|
||||
float const AngleY(glm::pi<float>() * 0.25f);
|
||||
|
||||
glm::vec3 const axisX(1.0f, 0.0f, 0.0f);
|
||||
glm::vec3 const axisY(0.0f, 1.0f, 0.0f);
|
||||
|
||||
glm::vec4 const V1 = (glm::rotate(glm::mat4(1.0f), AngleX, axisX) * glm::rotate(glm::mat4(1.0f), AngleY, axisY)) * V;
|
||||
glm::vec4 const V2 = glm::eulerAngleXY(AngleX, AngleY) * V;
|
||||
glm::vec4 const V3 = glm::eulerAngleX(AngleX) * glm::eulerAngleY(AngleY) * V;
|
||||
Error += glm::all(glm::epsilonEqual(V1, V2, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(V1, V3, 0.00001f)) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
}//namespace test_eulerAngleXY
|
||||
|
||||
namespace test_eulerAngleYX
|
||||
{
|
||||
int test()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::vec4 const V(1.0f);
|
||||
|
||||
float const AngleX(glm::pi<float>() * 0.5f);
|
||||
float const AngleY(glm::pi<float>() * 0.25f);
|
||||
|
||||
glm::vec3 const axisX(1.0f, 0.0f, 0.0f);
|
||||
glm::vec3 const axisY(0.0f, 1.0f, 0.0f);
|
||||
|
||||
glm::vec4 const V1 = (glm::rotate(glm::mat4(1.0f), AngleY, axisY) * glm::rotate(glm::mat4(1.0f), AngleX, axisX)) * V;
|
||||
glm::vec4 const V2 = glm::eulerAngleYX(AngleY, AngleX) * V;
|
||||
glm::vec4 const V3 = glm::eulerAngleY(AngleY) * glm::eulerAngleX(AngleX) * V;
|
||||
Error += glm::all(glm::epsilonEqual(V1, V2, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(V1, V3, 0.00001f)) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
}//namespace test_eulerAngleYX
|
||||
|
||||
namespace test_eulerAngleXZ
|
||||
{
|
||||
int test()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::vec4 const V(1.0f);
|
||||
|
||||
float const AngleX(glm::pi<float>() * 0.5f);
|
||||
float const AngleZ(glm::pi<float>() * 0.25f);
|
||||
|
||||
glm::vec3 const axisX(1.0f, 0.0f, 0.0f);
|
||||
glm::vec3 const axisZ(0.0f, 0.0f, 1.0f);
|
||||
|
||||
glm::vec4 const V1 = (glm::rotate(glm::mat4(1.0f), AngleX, axisX) * glm::rotate(glm::mat4(1.0f), AngleZ, axisZ)) * V;
|
||||
glm::vec4 const V2 = glm::eulerAngleXZ(AngleX, AngleZ) * V;
|
||||
glm::vec4 const V3 = glm::eulerAngleX(AngleX) * glm::eulerAngleZ(AngleZ) * V;
|
||||
Error += glm::all(glm::epsilonEqual(V1, V2, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(V1, V3, 0.00001f)) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
}//namespace test_eulerAngleXZ
|
||||
|
||||
namespace test_eulerAngleZX
|
||||
{
|
||||
int test()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::vec4 const V(1.0f);
|
||||
|
||||
float const AngleX(glm::pi<float>() * 0.5f);
|
||||
float const AngleZ(glm::pi<float>() * 0.25f);
|
||||
|
||||
glm::vec3 const axisX(1.0f, 0.0f, 0.0f);
|
||||
glm::vec3 const axisZ(0.0f, 0.0f, 1.0f);
|
||||
|
||||
glm::vec4 const V1 = (glm::rotate(glm::mat4(1.0f), AngleZ, axisZ) * glm::rotate(glm::mat4(1.0f), AngleX, axisX)) * V;
|
||||
glm::vec4 const V2 = glm::eulerAngleZX(AngleZ, AngleX) * V;
|
||||
glm::vec4 const V3 = glm::eulerAngleZ(AngleZ) * glm::eulerAngleX(AngleX) * V;
|
||||
Error += glm::all(glm::epsilonEqual(V1, V2, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(V1, V3, 0.00001f)) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
}//namespace test_eulerAngleZX
|
||||
|
||||
namespace test_eulerAngleYZ
|
||||
{
|
||||
int test()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::vec4 const V(1.0f);
|
||||
|
||||
float const AngleY(glm::pi<float>() * 0.5f);
|
||||
float const AngleZ(glm::pi<float>() * 0.25f);
|
||||
|
||||
glm::vec3 const axisX(1.0f, 0.0f, 0.0f);
|
||||
glm::vec3 const axisY(0.0f, 1.0f, 0.0f);
|
||||
glm::vec3 const axisZ(0.0f, 0.0f, 1.0f);
|
||||
|
||||
glm::vec4 const V1 = (glm::rotate(glm::mat4(1.0f), AngleY, axisY) * glm::rotate(glm::mat4(1.0f), AngleZ, axisZ)) * V;
|
||||
glm::vec4 const V2 = glm::eulerAngleYZ(AngleY, AngleZ) * V;
|
||||
glm::vec4 const V3 = glm::eulerAngleY(AngleY) * glm::eulerAngleZ(AngleZ) * V;
|
||||
Error += glm::all(glm::epsilonEqual(V1, V2, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(V1, V3, 0.00001f)) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
}//namespace test_eulerAngleYZ
|
||||
|
||||
namespace test_eulerAngleZY
|
||||
{
|
||||
int test()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::vec4 const V(1.0f);
|
||||
|
||||
float const AngleY(glm::pi<float>() * 0.5f);
|
||||
float const AngleZ(glm::pi<float>() * 0.25f);
|
||||
|
||||
glm::vec3 const axisX(1.0f, 0.0f, 0.0f);
|
||||
glm::vec3 const axisY(0.0f, 1.0f, 0.0f);
|
||||
glm::vec3 const axisZ(0.0f, 0.0f, 1.0f);
|
||||
|
||||
glm::vec4 const V1 = (glm::rotate(glm::mat4(1.0f), AngleZ, axisZ) * glm::rotate(glm::mat4(1.0f), AngleY, axisY)) * V;
|
||||
glm::vec4 const V2 = glm::eulerAngleZY(AngleZ, AngleY) * V;
|
||||
glm::vec4 const V3 = glm::eulerAngleZ(AngleZ) * glm::eulerAngleY(AngleY) * V;
|
||||
Error += glm::all(glm::epsilonEqual(V1, V2, 0.00001f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(V1, V3, 0.00001f)) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
}//namespace test_eulerAngleZY
|
||||
|
||||
namespace test_eulerAngleYXZ
|
||||
{
|
||||
int test()
|
||||
{
|
||||
glm::f32 first = 1.046f;
|
||||
glm::f32 second = 0.52f;
|
||||
glm::f32 third = -0.785f;
|
||||
|
||||
glm::fmat4 rotationEuler = glm::eulerAngleYXZ(first, second, third);
|
||||
|
||||
glm::fmat4 rotationInvertedY = glm::eulerAngleY(-1.f*first) * glm::eulerAngleX(second) * glm::eulerAngleZ(third);
|
||||
glm::fmat4 rotationDumb = glm::fmat4();
|
||||
rotationDumb = glm::rotate(rotationDumb, first, glm::fvec3(0,1,0));
|
||||
rotationDumb = glm::rotate(rotationDumb, second, glm::fvec3(1,0,0));
|
||||
rotationDumb = glm::rotate(rotationDumb, third, glm::fvec3(0,0,1));
|
||||
|
||||
std::printf("%s\n", glm::to_string(glm::fmat3(rotationEuler)).c_str());
|
||||
std::printf("%s\n", glm::to_string(glm::fmat3(rotationDumb)).c_str());
|
||||
std::printf("%s\n", glm::to_string(glm::fmat3(rotationInvertedY)).c_str());
|
||||
|
||||
std::printf("\nRESIDUAL\n");
|
||||
std::printf("%s\n", glm::to_string(glm::fmat3(rotationEuler-(rotationDumb))).c_str());
|
||||
std::printf("%s\n", glm::to_string(glm::fmat3(rotationEuler-(rotationInvertedY))).c_str());
|
||||
|
||||
return 0;
|
||||
}
|
||||
}//namespace eulerAngleYXZ
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
Error += test_eulerAngleX::test();
|
||||
Error += test_eulerAngleY::test();
|
||||
Error += test_eulerAngleZ::test();
|
||||
Error += test_eulerAngleXY::test();
|
||||
Error += test_eulerAngleYX::test();
|
||||
Error += test_eulerAngleXZ::test();
|
||||
Error += test_eulerAngleZX::test();
|
||||
Error += test_eulerAngleYZ::test();
|
||||
Error += test_eulerAngleZY::test();
|
||||
Error += test_eulerAngleYXZ::test();
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <glm/gtx/extend.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <glm/gtx/extended_min_max.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
/// OpenGL Mathematics (glm.g-truc.net)
|
||||
///
|
||||
/// Copyright (c) 2005 - 2015 G-Truc Creation (www.g-truc.net)
|
||||
/// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
/// of this software and associated documentation files (the "Software"), to deal
|
||||
/// in the Software without restriction, including without limitation the rights
|
||||
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
/// copies of the Software, and to permit persons to whom the Software is
|
||||
/// furnished to do so, subject to the following conditions:
|
||||
///
|
||||
/// The above copyright notice and this permission notice shall be included in
|
||||
/// all copies or substantial portions of the Software.
|
||||
///
|
||||
/// Restrictions:
|
||||
/// By making use of the Software for military purposes, you choose to make
|
||||
/// a Bunny unhappy.
|
||||
///
|
||||
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
/// THE SOFTWARE.
|
||||
///
|
||||
/// @file test/gtx/gtx_extented_min_max.cpp
|
||||
/// @date 2013-10-25 / 2014-11-25
|
||||
/// @author Christophe Riccio
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/gtx/extended_min_max.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <glm/gtx/fast_exponential.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
#include <glm/gtx/fast_square_root.hpp>
|
||||
#include <glm/gtc/type_precision.hpp>
|
||||
#include <glm/gtc/epsilon.hpp>
|
||||
#include <glm/vector_relational.hpp>
|
||||
|
||||
int test_fastInverseSqrt()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += glm::epsilonEqual(glm::fastInverseSqrt(1.0f), 1.0f, 0.01f) ? 0 : 1;
|
||||
Error += glm::epsilonEqual(glm::fastInverseSqrt(1.0), 1.0, 0.01) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(glm::fastInverseSqrt(glm::vec2(1.0f)), glm::vec2(1.0f), 0.01f)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(glm::fastInverseSqrt(glm::dvec3(1.0)), glm::dvec3(1.0), 0.01)) ? 0 : 1;
|
||||
Error += glm::all(glm::epsilonEqual(glm::fastInverseSqrt(glm::dvec4(1.0)), glm::dvec4(1.0), 0.01)) ? 0 : 1;
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int test_fastDistance()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
glm::mediump_f32 A = glm::fastDistance(glm::mediump_f32(0.0f), glm::mediump_f32(1.0f));
|
||||
glm::mediump_f32 B = glm::fastDistance(glm::mediump_f32vec2(0.0f), glm::mediump_f32vec2(1.0f, 0.0f));
|
||||
glm::mediump_f32 C = glm::fastDistance(glm::mediump_f32vec3(0.0f), glm::mediump_f32vec3(1.0f, 0.0f, 0.0f));
|
||||
glm::mediump_f32 D = glm::fastDistance(glm::mediump_f32vec4(0.0f), glm::mediump_f32vec4(1.0f, 0.0f, 0.0f, 0.0f));
|
||||
|
||||
Error += glm::epsilonEqual(A, glm::mediump_f32(1.0f), glm::mediump_f32(0.01f)) ? 0 : 1;
|
||||
Error += glm::epsilonEqual(B, glm::mediump_f32(1.0f), glm::mediump_f32(0.01f)) ? 0 : 1;
|
||||
Error += glm::epsilonEqual(C, glm::mediump_f32(1.0f), glm::mediump_f32(0.01f)) ? 0 : 1;
|
||||
Error += glm::epsilonEqual(D, glm::mediump_f32(1.0f), glm::mediump_f32(0.01f)) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += test_fastInverseSqrt();
|
||||
Error += test_fastDistance();
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,445 @@
|
||||
#include <glm/gtc/type_precision.hpp>
|
||||
#include <glm/gtx/fast_trigonometry.hpp>
|
||||
#include <glm/gtx/integer.hpp>
|
||||
#include <glm/gtx/common.hpp>
|
||||
#include <glm/gtc/constants.hpp>
|
||||
#include <glm/gtc/ulp.hpp>
|
||||
#include <glm/gtc/vec1.hpp>
|
||||
#include <glm/trigonometric.hpp>
|
||||
#include <cmath>
|
||||
#include <ctime>
|
||||
#include <cstdio>
|
||||
#include <vector>
|
||||
|
||||
namespace fastCos
|
||||
{
|
||||
int perf(bool NextFloat)
|
||||
{
|
||||
const float begin = -glm::pi<float>();
|
||||
const float end = glm::pi<float>();
|
||||
float result = 0.f;
|
||||
|
||||
const std::clock_t timestamp1 = std::clock();
|
||||
for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
|
||||
result = glm::fastCos(i);
|
||||
|
||||
const std::clock_t timestamp2 = std::clock();
|
||||
for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
|
||||
result = glm::cos(i);
|
||||
|
||||
const std::clock_t timestamp3 = std::clock();
|
||||
const std::clock_t time_fast = timestamp2 - timestamp1;
|
||||
const std::clock_t time_default = timestamp3 - timestamp2;
|
||||
std::printf("fastCos Time %d clocks\n", static_cast<unsigned int>(time_fast));
|
||||
std::printf("cos Time %d clocks\n", static_cast<unsigned int>(time_default));
|
||||
|
||||
return time_fast <= time_default ? 0 : 1;
|
||||
}
|
||||
}//namespace fastCos
|
||||
|
||||
namespace fastSin
|
||||
{
|
||||
/*
|
||||
float sin(float x) {
|
||||
float temp;
|
||||
temp = (x + M_PI) / ((2 * M_PI) - M_PI);
|
||||
return limited_sin((x + M_PI) - ((2 * M_PI) - M_PI) * temp));
|
||||
}
|
||||
*/
|
||||
|
||||
int perf(bool NextFloat)
|
||||
{
|
||||
const float begin = -glm::pi<float>();
|
||||
const float end = glm::pi<float>();
|
||||
float result = 0.f;
|
||||
|
||||
const std::clock_t timestamp1 = std::clock();
|
||||
for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
|
||||
result = glm::fastSin(i);
|
||||
|
||||
const std::clock_t timestamp2 = std::clock();
|
||||
for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
|
||||
result = glm::sin(i);
|
||||
|
||||
const std::clock_t timestamp3 = std::clock();
|
||||
const std::clock_t time_fast = timestamp2 - timestamp1;
|
||||
const std::clock_t time_default = timestamp3 - timestamp2;
|
||||
std::printf("fastSin Time %d clocks\n", static_cast<unsigned int>(time_fast));
|
||||
std::printf("sin Time %d clocks\n", static_cast<unsigned int>(time_default));
|
||||
|
||||
return time_fast <= time_default ? 0 : 1;
|
||||
}
|
||||
}//namespace fastSin
|
||||
|
||||
namespace fastTan
|
||||
{
|
||||
int perf(bool NextFloat)
|
||||
{
|
||||
const float begin = -glm::pi<float>();
|
||||
const float end = glm::pi<float>();
|
||||
float result = 0.f;
|
||||
|
||||
const std::clock_t timestamp1 = std::clock();
|
||||
for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
|
||||
result = glm::fastTan(i);
|
||||
|
||||
const std::clock_t timestamp2 = std::clock();
|
||||
for (float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
|
||||
result = glm::tan(i);
|
||||
|
||||
const std::clock_t timestamp3 = std::clock();
|
||||
const std::clock_t time_fast = timestamp2 - timestamp1;
|
||||
const std::clock_t time_default = timestamp3 - timestamp2;
|
||||
std::printf("fastTan Time %d clocks\n", static_cast<unsigned int>(time_fast));
|
||||
std::printf("tan Time %d clocks\n", static_cast<unsigned int>(time_default));
|
||||
|
||||
return time_fast <= time_default ? 0 : 1;
|
||||
}
|
||||
}//namespace fastTan
|
||||
|
||||
namespace fastAcos
|
||||
{
|
||||
int perf(bool NextFloat)
|
||||
{
|
||||
const float begin = -glm::pi<float>();
|
||||
const float end = glm::pi<float>();
|
||||
float result = 0.f;
|
||||
|
||||
const std::clock_t timestamp1 = std::clock();
|
||||
for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
|
||||
result = glm::fastAcos(i);
|
||||
|
||||
const std::clock_t timestamp2 = std::clock();
|
||||
for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
|
||||
result = glm::acos(i);
|
||||
|
||||
const std::clock_t timestamp3 = std::clock();
|
||||
const std::clock_t time_fast = timestamp2 - timestamp1;
|
||||
const std::clock_t time_default = timestamp3 - timestamp2;
|
||||
|
||||
std::printf("fastAcos Time %d clocks\n", static_cast<unsigned int>(time_fast));
|
||||
std::printf("acos Time %d clocks\n", static_cast<unsigned int>(time_default));
|
||||
|
||||
return time_fast <= time_default ? 0 : 1;
|
||||
}
|
||||
}//namespace fastAcos
|
||||
|
||||
namespace fastAsin
|
||||
{
|
||||
int perf(bool NextFloat)
|
||||
{
|
||||
const float begin = -glm::pi<float>();
|
||||
const float end = glm::pi<float>();
|
||||
float result = 0.f;
|
||||
const std::clock_t timestamp1 = std::clock();
|
||||
for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
|
||||
result = glm::fastAsin(i);
|
||||
const std::clock_t timestamp2 = std::clock();
|
||||
for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
|
||||
result = glm::asin(i);
|
||||
const std::clock_t timestamp3 = std::clock();
|
||||
const std::clock_t time_fast = timestamp2 - timestamp1;
|
||||
const std::clock_t time_default = timestamp3 - timestamp2;
|
||||
std::printf("fastAsin Time %d clocks\n", static_cast<unsigned int>(time_fast));
|
||||
std::printf("asin Time %d clocks\n", static_cast<unsigned int>(time_default));
|
||||
|
||||
return time_fast <= time_default ? 0 : 1;
|
||||
}
|
||||
}//namespace fastAsin
|
||||
|
||||
namespace fastAtan
|
||||
{
|
||||
int perf(bool NextFloat)
|
||||
{
|
||||
const float begin = -glm::pi<float>();
|
||||
const float end = glm::pi<float>();
|
||||
float result = 0.f;
|
||||
const std::clock_t timestamp1 = std::clock();
|
||||
for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
|
||||
result = glm::fastAtan(i);
|
||||
const std::clock_t timestamp2 = std::clock();
|
||||
for(float i = begin; i < end; i = NextFloat ? glm::next_float(i) : i += 0.1f)
|
||||
result = glm::atan(i);
|
||||
const std::clock_t timestamp3 = std::clock();
|
||||
const std::clock_t time_fast = timestamp2 - timestamp1;
|
||||
const std::clock_t time_default = timestamp3 - timestamp2;
|
||||
std::printf("fastAtan Time %d clocks\n", static_cast<unsigned int>(time_fast));
|
||||
std::printf("atan Time %d clocks\n", static_cast<unsigned int>(time_default));
|
||||
|
||||
return time_fast <= time_default ? 0 : 1;
|
||||
}
|
||||
}//namespace fastAtan
|
||||
|
||||
namespace taylorCos
|
||||
{
|
||||
glm::vec4 const AngleShift(0.0f, glm::pi<float>() * 0.5f, glm::pi<float>() * 1.0f, glm::pi<float>() * 1.5f);
|
||||
|
||||
template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
|
||||
GLM_FUNC_QUALIFIER vecType<T, P> taylorSeriesNewCos(vecType<T, P> const & x)
|
||||
{
|
||||
vecType<T, P> const Powed2(x * x);
|
||||
vecType<T, P> const Powed4(Powed2 * Powed2);
|
||||
vecType<T, P> const Powed6(Powed4 * Powed2);
|
||||
vecType<T, P> const Powed8(Powed4 * Powed4);
|
||||
|
||||
return static_cast<T>(1)
|
||||
- Powed2 * static_cast<T>(0.5)
|
||||
+ Powed4 * static_cast<T>(0.04166666666666666666666666666667)
|
||||
- Powed6 * static_cast<T>(0.00138888888888888888888888888889)
|
||||
+ Powed8 * static_cast<T>(2.4801587301587301587301587301587e-5);
|
||||
}
|
||||
|
||||
template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
|
||||
GLM_FUNC_QUALIFIER vecType<T, P> taylorSeriesNewCos6(vecType<T, P> const & x)
|
||||
{
|
||||
vecType<T, P> const Powed2(x * x);
|
||||
vecType<T, P> const Powed4(Powed2 * Powed2);
|
||||
vecType<T, P> const Powed6(Powed4 * Powed2);
|
||||
|
||||
return static_cast<T>(1)
|
||||
- Powed2 * static_cast<T>(0.5)
|
||||
+ Powed4 * static_cast<T>(0.04166666666666666666666666666667)
|
||||
- Powed6 * static_cast<T>(0.00138888888888888888888888888889);
|
||||
}
|
||||
|
||||
template <glm::precision P, template <typename, glm::precision> class vecType>
|
||||
GLM_FUNC_QUALIFIER vecType<float, P> fastAbs(vecType<float, P> x)
|
||||
{
|
||||
int* Pointer = reinterpret_cast<int*>(&x[0]);
|
||||
Pointer[0] &= 0x7fffffff;
|
||||
Pointer[1] &= 0x7fffffff;
|
||||
Pointer[2] &= 0x7fffffff;
|
||||
Pointer[3] &= 0x7fffffff;
|
||||
return x;
|
||||
}
|
||||
|
||||
template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
|
||||
GLM_FUNC_QUALIFIER vecType<T, P> fastCosNew(vecType<T, P> const & x)
|
||||
{
|
||||
vecType<T, P> const Angle0_PI(fastAbs(fmod(x + glm::pi<T>(), glm::two_pi<T>()) - glm::pi<T>()));
|
||||
return taylorSeriesNewCos6(x);
|
||||
/*
|
||||
vecType<bool, P> const FirstQuarterPi(lessThanEqual(Angle0_PI, vecType<T, P>(glm::half_pi<T>())));
|
||||
|
||||
vecType<T, P> const RevertAngle(mix(vecType<T, P>(glm::pi<T>()), vecType<T, P>(0), FirstQuarterPi));
|
||||
vecType<T, P> const ReturnSign(mix(vecType<T, P>(-1), vecType<T, P>(1), FirstQuarterPi));
|
||||
vecType<T, P> const SectionAngle(RevertAngle - Angle0_PI);
|
||||
|
||||
return ReturnSign * taylorSeriesNewCos(SectionAngle);
|
||||
*/
|
||||
}
|
||||
|
||||
int perf_fastCosNew(float Begin, float End, std::size_t Samples)
|
||||
{
|
||||
std::vector<glm::vec4> Results;
|
||||
Results.resize(Samples);
|
||||
|
||||
float Steps = (End - Begin) / Samples;
|
||||
|
||||
std::clock_t const TimeStampBegin = std::clock();
|
||||
|
||||
for(std::size_t i = 0; i < Samples; ++i)
|
||||
Results[i] = fastCosNew(AngleShift + glm::vec4(Begin + Steps * i));
|
||||
|
||||
std::clock_t const TimeStampEnd = std::clock();
|
||||
|
||||
std::printf("fastCosNew %ld clocks\n", TimeStampEnd - TimeStampBegin);
|
||||
|
||||
int Error = 0;
|
||||
for(std::size_t i = 0; i < Samples; ++i)
|
||||
Error += Results[i].x >= -1.0f && Results[i].x <= 1.0f ? 0 : 1;
|
||||
return Error;
|
||||
}
|
||||
|
||||
template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
|
||||
GLM_FUNC_QUALIFIER vecType<T, P> deterministic_fmod(vecType<T, P> const & x, T y)
|
||||
{
|
||||
return x - y * trunc(x / y);
|
||||
}
|
||||
|
||||
template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
|
||||
GLM_FUNC_QUALIFIER vecType<T, P> fastCosDeterminisctic(vecType<T, P> const & x)
|
||||
{
|
||||
vecType<T, P> const Angle0_PI(abs(deterministic_fmod(x + glm::pi<T>(), glm::two_pi<T>()) - glm::pi<T>()));
|
||||
vecType<bool, P> const FirstQuarterPi(lessThanEqual(Angle0_PI, vecType<T, P>(glm::half_pi<T>())));
|
||||
|
||||
vecType<T, P> const RevertAngle(mix(vecType<T, P>(glm::pi<T>()), vecType<T, P>(0), FirstQuarterPi));
|
||||
vecType<T, P> const ReturnSign(mix(vecType<T, P>(-1), vecType<T, P>(1), FirstQuarterPi));
|
||||
vecType<T, P> const SectionAngle(RevertAngle - Angle0_PI);
|
||||
|
||||
return ReturnSign * taylorSeriesNewCos(SectionAngle);
|
||||
}
|
||||
|
||||
int perf_fastCosDeterminisctic(float Begin, float End, std::size_t Samples)
|
||||
{
|
||||
std::vector<glm::vec4> Results;
|
||||
Results.resize(Samples);
|
||||
|
||||
float Steps = (End - Begin) / Samples;
|
||||
|
||||
std::clock_t const TimeStampBegin = std::clock();
|
||||
|
||||
for(std::size_t i = 0; i < Samples; ++i)
|
||||
Results[i] = taylorCos::fastCosDeterminisctic(AngleShift + glm::vec4(Begin + Steps * i));
|
||||
|
||||
std::clock_t const TimeStampEnd = std::clock();
|
||||
|
||||
std::printf("fastCosDeterminisctic %ld clocks\n", TimeStampEnd - TimeStampBegin);
|
||||
|
||||
int Error = 0;
|
||||
for(std::size_t i = 0; i < Samples; ++i)
|
||||
Error += Results[i].x >= -1.0f && Results[i].x <= 1.0f ? 0 : 1;
|
||||
return Error;
|
||||
}
|
||||
|
||||
template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
|
||||
GLM_FUNC_QUALIFIER vecType<T, P> taylorSeriesRefCos(vecType<T, P> const & x)
|
||||
{
|
||||
return static_cast<T>(1)
|
||||
- (x * x) / glm::factorial(static_cast<T>(2))
|
||||
+ (x * x * x * x) / glm::factorial(static_cast<T>(4))
|
||||
- (x * x * x * x * x * x) / glm::factorial(static_cast<T>(6))
|
||||
+ (x * x * x * x * x * x * x * x) / glm::factorial(static_cast<T>(8));
|
||||
}
|
||||
|
||||
template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
|
||||
GLM_FUNC_QUALIFIER vecType<T, P> fastRefCos(vecType<T, P> const & x)
|
||||
{
|
||||
vecType<T, P> const Angle0_PI(glm::abs(fmod(x + glm::pi<T>(), glm::two_pi<T>()) - glm::pi<T>()));
|
||||
// return taylorSeriesRefCos(Angle0_PI);
|
||||
|
||||
vecType<bool, P> const FirstQuarterPi(lessThanEqual(Angle0_PI, vecType<T, P>(glm::half_pi<T>())));
|
||||
|
||||
vecType<T, P> const RevertAngle(mix(vecType<T, P>(glm::pi<T>()), vecType<T, P>(0), FirstQuarterPi));
|
||||
vecType<T, P> const ReturnSign(mix(vecType<T, P>(-1), vecType<T, P>(1), FirstQuarterPi));
|
||||
vecType<T, P> const SectionAngle(RevertAngle - Angle0_PI);
|
||||
|
||||
return ReturnSign * taylorSeriesRefCos(SectionAngle);
|
||||
}
|
||||
|
||||
int perf_fastCosRef(float Begin, float End, std::size_t Samples)
|
||||
{
|
||||
std::vector<glm::vec4> Results;
|
||||
Results.resize(Samples);
|
||||
|
||||
float Steps = (End - Begin) / Samples;
|
||||
|
||||
std::clock_t const TimeStampBegin = std::clock();
|
||||
|
||||
for(std::size_t i = 0; i < Samples; ++i)
|
||||
Results[i] = taylorCos::fastRefCos(AngleShift + glm::vec4(Begin + Steps * i));
|
||||
|
||||
std::clock_t const TimeStampEnd = std::clock();
|
||||
|
||||
std::printf("fastCosRef %ld clocks\n", TimeStampEnd - TimeStampBegin);
|
||||
|
||||
int Error = 0;
|
||||
for(std::size_t i = 0; i < Samples; ++i)
|
||||
Error += Results[i].x >= -1.0f && Results[i].x <= 1.0f ? 0 : 1;
|
||||
return Error;
|
||||
}
|
||||
|
||||
int perf_fastCosOld(float Begin, float End, std::size_t Samples)
|
||||
{
|
||||
std::vector<glm::vec4> Results;
|
||||
Results.resize(Samples);
|
||||
|
||||
float Steps = (End - Begin) / Samples;
|
||||
|
||||
std::clock_t const TimeStampBegin = std::clock();
|
||||
|
||||
for(std::size_t i = 0; i < Samples; ++i)
|
||||
Results[i] = glm::fastCos(AngleShift + glm::vec4(Begin + Steps * i));
|
||||
|
||||
std::clock_t const TimeStampEnd = std::clock();
|
||||
|
||||
std::printf("fastCosOld %ld clocks\n", TimeStampEnd - TimeStampBegin);
|
||||
|
||||
int Error = 0;
|
||||
for(std::size_t i = 0; i < Samples; ++i)
|
||||
Error += Results[i].x >= -1.0f && Results[i].x <= 1.0f ? 0 : 1;
|
||||
return Error;
|
||||
}
|
||||
|
||||
int perf_cos(float Begin, float End, std::size_t Samples)
|
||||
{
|
||||
std::vector<glm::vec4> Results;
|
||||
Results.resize(Samples);
|
||||
|
||||
float Steps = (End - Begin) / Samples;
|
||||
|
||||
std::clock_t const TimeStampBegin = std::clock();
|
||||
|
||||
for(std::size_t i = 0; i < Samples; ++i)
|
||||
Results[i] = glm::cos(AngleShift + glm::vec4(Begin + Steps * i));
|
||||
|
||||
std::clock_t const TimeStampEnd = std::clock();
|
||||
|
||||
std::printf("cos %ld clocks\n", TimeStampEnd - TimeStampBegin);
|
||||
|
||||
int Error = 0;
|
||||
for(std::size_t i = 0; i < Samples; ++i)
|
||||
Error += Results[i].x >= -1.0f && Results[i].x <= 1.0f ? 0 : 1;
|
||||
return Error;
|
||||
}
|
||||
|
||||
int perf(std::size_t const Samples)
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
float const Begin = -glm::pi<float>();
|
||||
float const End = glm::pi<float>();
|
||||
|
||||
Error += perf_cos(Begin, End, Samples);
|
||||
Error += perf_fastCosOld(Begin, End, Samples);
|
||||
Error += perf_fastCosRef(Begin, End, Samples);
|
||||
//Error += perf_fastCosNew(Begin, End, Samples);
|
||||
Error += perf_fastCosDeterminisctic(Begin, End, Samples);
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
//for(float Angle = -4.0f * glm::pi<float>(); Angle < 4.0f * glm::pi<float>(); Angle += 0.1f)
|
||||
//for(float Angle = -720.0f; Angle < 720.0f; Angle += 0.1f)
|
||||
for(float Angle = 0.0f; Angle < 180.0f; Angle += 0.1f)
|
||||
{
|
||||
float const modAngle = std::fmod(glm::abs(Angle), 360.f);
|
||||
assert(modAngle >= 0.0f && modAngle <= 360.f);
|
||||
float const radAngle = glm::radians(modAngle);
|
||||
float const Cos0 = std::cos(radAngle);
|
||||
|
||||
float const Cos1 = taylorCos::fastRefCos(glm::fvec1(radAngle)).x;
|
||||
Error += glm::abs(Cos1 - Cos0) < 0.1f ? 0 : 1;
|
||||
|
||||
float const Cos2 = taylorCos::fastCosNew(glm::fvec1(radAngle)).x;
|
||||
//Error += glm::abs(Cos2 - Cos0) < 0.1f ? 0 : 1;
|
||||
|
||||
assert(!Error);
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
}//namespace taylorCos
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += ::taylorCos::test();
|
||||
Error += ::taylorCos::perf(1000);
|
||||
|
||||
# ifdef NDEBUG
|
||||
::fastCos::perf(false);
|
||||
::fastSin::perf(false);
|
||||
::fastTan::perf(false);
|
||||
::fastAcos::perf(false);
|
||||
::fastAsin::perf(false);
|
||||
::fastAtan::perf(false);
|
||||
# endif//NDEBUG
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
#include <glm/gtx/gradient_paint.hpp>
|
||||
|
||||
int test_radialGradient()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
float Gradient = glm::radialGradient(glm::vec2(0), 1.0f, glm::vec2(1), glm::vec2(0.5));
|
||||
Error += Gradient != 0.0f ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_linearGradient()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
float Gradient = glm::linearGradient(glm::vec2(0), glm::vec2(1), glm::vec2(0.5));
|
||||
Error += Gradient != 0.0f ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
Error += test_radialGradient();
|
||||
Error += test_linearGradient();
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <glm/gtx/handed_coordinate_space.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/associated_min_max.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/gtc/type_precision.hpp>
|
||||
#include <glm/gtx/associated_min_max.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
#include <glm/exponential.hpp>
|
||||
#include <glm/gtc/epsilon.hpp>
|
||||
#include <glm/gtx/integer.hpp>
|
||||
#include <cstdio>
|
||||
/*
|
||||
int test_floor_log2()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
for(std::size_t i = 1; i < 1000000; ++i)
|
||||
{
|
||||
glm::uint A = glm::floor_log2(glm::uint(i));
|
||||
glm::uint B = glm::uint(glm::floor(glm::log2(double(i)))); // Will fail with float, lack of accuracy
|
||||
|
||||
Error += A == B ? 0 : 1;
|
||||
assert(!Error);
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
*/
|
||||
int test_log2()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
for(std::size_t i = 1; i < 24; ++i)
|
||||
{
|
||||
glm::uint A = glm::log2(glm::uint(1 << i));
|
||||
glm::uint B = glm::uint(glm::log2(double(1 << i)));
|
||||
|
||||
//Error += glm::equalEpsilon(double(A), B, 1.0) ? 0 : 1;
|
||||
Error += glm::abs(double(A) - B) <= 24 ? 0 : 1;
|
||||
assert(!Error);
|
||||
|
||||
printf("Log2(%d) error A=%d, B=%d\n", 1 << i, A, B);
|
||||
}
|
||||
|
||||
printf("log2 error=%d\n", Error);
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_nlz()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
for(glm::uint i = 1; i < glm::uint(33); ++i)
|
||||
Error += glm::nlz(i) == glm::uint(31u) - glm::findMSB(i) ? 0 : 1;
|
||||
//printf("%d, %d\n", glm::nlz(i), 31u - glm::findMSB(i));
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
Error += test_nlz();
|
||||
// Error += test_floor_log2();
|
||||
Error += test_log2();
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <glm/gtx/intersect.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,175 @@
|
||||
#include <glm/gtc/type_precision.hpp>
|
||||
#include <glm/gtx/io.hpp>
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
#include <typeinfo>
|
||||
|
||||
namespace
|
||||
{
|
||||
template <typename CTy, typename CTr>
|
||||
std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>& os, glm::precision const& a)
|
||||
{
|
||||
typename std::basic_ostream<CTy,CTr>::sentry const cerberus(os);
|
||||
|
||||
if (cerberus)
|
||||
{
|
||||
switch (a) {
|
||||
case glm::highp: os << "uhi"; break;
|
||||
case glm::mediump: os << "umd"; break;
|
||||
case glm::lowp: os << "ulo"; break;
|
||||
# if GLM_HAS_ALIGNED_TYPE
|
||||
case glm::aligned_highp: os << "ahi"; break;
|
||||
case glm::aligned_mediump: os << "amd"; break;
|
||||
case glm::aligned_lowp: os << "alo"; break;
|
||||
# endif
|
||||
}
|
||||
}
|
||||
|
||||
return os;
|
||||
}
|
||||
|
||||
template <typename U, glm::precision P, typename T, typename CTy, typename CTr>
|
||||
std::basic_string<CTy> type_name(std::basic_ostream<CTy,CTr>& os, T const&)
|
||||
{
|
||||
std::basic_ostringstream<CTy,CTr> ostr;
|
||||
|
||||
if (typeid(T) == typeid(glm::tquat<U,P>)) { ostr << "quat"; }
|
||||
else if (typeid(T) == typeid(glm::tvec2<U,P>)) { ostr << "vec2"; }
|
||||
else if (typeid(T) == typeid(glm::tvec3<U,P>)) { ostr << "vec3"; }
|
||||
else if (typeid(T) == typeid(glm::tvec4<U,P>)) { ostr << "vec4"; }
|
||||
else if (typeid(T) == typeid(glm::tmat2x2<U,P>)) { ostr << "mat2x2"; }
|
||||
else if (typeid(T) == typeid(glm::tmat2x3<U,P>)) { ostr << "mat2x3"; }
|
||||
else if (typeid(T) == typeid(glm::tmat2x4<U,P>)) { ostr << "mat2x4"; }
|
||||
else if (typeid(T) == typeid(glm::tmat3x2<U,P>)) { ostr << "mat3x2"; }
|
||||
else if (typeid(T) == typeid(glm::tmat3x3<U,P>)) { ostr << "mat3x3"; }
|
||||
else if (typeid(T) == typeid(glm::tmat3x4<U,P>)) { ostr << "mat3x4"; }
|
||||
else if (typeid(T) == typeid(glm::tmat4x2<U,P>)) { ostr << "mat4x2"; }
|
||||
else if (typeid(T) == typeid(glm::tmat4x3<U,P>)) { ostr << "mat4x3"; }
|
||||
else if (typeid(T) == typeid(glm::tmat4x4<U,P>)) { ostr << "mat4x4"; }
|
||||
else { ostr << "unknown"; }
|
||||
|
||||
ostr << '<' << typeid(U).name() << ',' << P << '>';
|
||||
|
||||
return ostr.str();
|
||||
}
|
||||
} // namespace {
|
||||
|
||||
template <typename T, glm::precision P, typename OS>
|
||||
int test_io_quat(OS& os)
|
||||
{
|
||||
os << '\n' << typeid(OS).name() << '\n';
|
||||
|
||||
glm::tquat<T,P> const q(1, 0, 0, 0);
|
||||
|
||||
{
|
||||
glm::io::basic_format_saver<typename OS::char_type> const iofs(os);
|
||||
|
||||
os << glm::io::precision(2) << glm::io::width(1 + 2 + 1 + 2)
|
||||
<< type_name<T,P>(os, q) << ": " << q << '\n';
|
||||
}
|
||||
|
||||
{
|
||||
glm::io::basic_format_saver<typename OS::char_type> const iofs(os);
|
||||
|
||||
os << glm::io::unformatted
|
||||
<< type_name<T,P>(os, q) << ": " << q << '\n';
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
template <typename T, glm::precision P, typename OS>
|
||||
int test_io_vec(OS& os)
|
||||
{
|
||||
os << '\n' << typeid(OS).name() << '\n';
|
||||
|
||||
glm::tvec2<T,P> const v2(0, 1);
|
||||
glm::tvec3<T,P> const v3(2, 3, 4);
|
||||
glm::tvec4<T,P> const v4(5, 6, 7, 8);
|
||||
|
||||
os << type_name<T,P>(os, v2) << ": " << v2 << '\n'
|
||||
<< type_name<T,P>(os, v3) << ": " << v3 << '\n'
|
||||
<< type_name<T,P>(os, v4) << ": " << v4 << '\n';
|
||||
|
||||
glm::io::basic_format_saver<typename OS::char_type> const iofs(os);
|
||||
|
||||
os << glm::io::precision(2) << glm::io::width(1 + 2 + 1 + 2)
|
||||
<< type_name<T,P>(os, v2) << ": " << v2 << '\n'
|
||||
<< type_name<T,P>(os, v3) << ": " << v3 << '\n'
|
||||
<< type_name<T,P>(os, v4) << ": " << v4 << '\n';
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
template <typename T, glm::precision P, typename OS>
|
||||
int test_io_mat(OS& os, glm::io::order_type otype)
|
||||
{
|
||||
os << '\n' << typeid(OS).name() << '\n';
|
||||
|
||||
glm::tvec2<T,P> const v2_1( 0, 1);
|
||||
glm::tvec2<T,P> const v2_2( 2, 3);
|
||||
glm::tvec2<T,P> const v2_3( 4, 5);
|
||||
glm::tvec2<T,P> const v2_4( 6, 7);
|
||||
glm::tvec3<T,P> const v3_1( 8, 9, 10);
|
||||
glm::tvec3<T,P> const v3_2(11, 12, 13);
|
||||
glm::tvec3<T,P> const v3_3(14, 15, 16);
|
||||
glm::tvec3<T,P> const v3_4(17, 18, 19);
|
||||
glm::tvec4<T,P> const v4_1(20, 21, 22, 23);
|
||||
glm::tvec4<T,P> const v4_2(24, 25, 26, 27);
|
||||
glm::tvec4<T,P> const v4_3(28, 29, 30, 31);
|
||||
glm::tvec4<T,P> const v4_4(32, 33, 34, 35);
|
||||
|
||||
glm::io::basic_format_saver<typename OS::char_type> const iofs(os);
|
||||
|
||||
os << glm::io::precision(2) << glm::io::width(1 + 2 + 1 + 2)
|
||||
<< glm::io::order(otype)
|
||||
<< "mat2x2<" << typeid(T).name() << ',' << P << ">: " << glm::tmat2x2<T,P>(v2_1, v2_2) << '\n'
|
||||
<< "mat2x3<" << typeid(T).name() << ',' << P << ">: " << glm::tmat2x3<T,P>(v3_1, v3_2) << '\n'
|
||||
<< "mat2x4<" << typeid(T).name() << ',' << P << ">: " << glm::tmat2x4<T,P>(v4_1, v4_2) << '\n'
|
||||
<< "mat3x2<" << typeid(T).name() << ',' << P << ">: " << glm::tmat3x2<T,P>(v2_1, v2_2, v2_3) << '\n'
|
||||
<< "mat3x3<" << typeid(T).name() << ',' << P << ">: " << glm::tmat3x3<T,P>(v3_1, v3_2, v3_3) << '\n'
|
||||
<< "mat3x4<" << typeid(T).name() << ',' << P << ">: " << glm::tmat3x4<T,P>(v4_1, v4_2, v4_3) << '\n'
|
||||
<< "mat4x2<" << typeid(T).name() << ',' << P << ">: " << glm::tmat4x2<T,P>(v2_1, v2_2, v2_3, v2_4) << '\n'
|
||||
<< "mat4x3<" << typeid(T).name() << ',' << P << ">: " << glm::tmat4x3<T,P>(v3_1, v3_2, v3_3, v3_4) << '\n'
|
||||
<< "mat4x4<" << typeid(T).name() << ',' << P << ">: " << glm::tmat4x4<T,P>(v4_1, v4_2, v4_3, v4_4) << '\n';
|
||||
|
||||
os << glm::io::unformatted
|
||||
<< glm::io::order(otype)
|
||||
<< "mat2x2<" << typeid(T).name() << ',' << P << ">: " << glm::tmat2x2<T,P>(v2_1, v2_2) << '\n'
|
||||
<< "mat2x3<" << typeid(T).name() << ',' << P << ">: " << glm::tmat2x3<T,P>(v3_1, v3_2) << '\n'
|
||||
<< "mat2x4<" << typeid(T).name() << ',' << P << ">: " << glm::tmat2x4<T,P>(v4_1, v4_2) << '\n'
|
||||
<< "mat3x2<" << typeid(T).name() << ',' << P << ">: " << glm::tmat3x2<T,P>(v2_1, v2_2, v2_3) << '\n'
|
||||
<< "mat3x3<" << typeid(T).name() << ',' << P << ">: " << glm::tmat3x3<T,P>(v3_1, v3_2, v3_3) << '\n'
|
||||
<< "mat3x4<" << typeid(T).name() << ',' << P << ">: " << glm::tmat3x4<T,P>(v4_1, v4_2, v4_3) << '\n'
|
||||
<< "mat4x2<" << typeid(T).name() << ',' << P << ">: " << glm::tmat4x2<T,P>(v2_1, v2_2, v2_3, v2_4) << '\n'
|
||||
<< "mat4x3<" << typeid(T).name() << ',' << P << ">: " << glm::tmat4x3<T,P>(v3_1, v3_2, v3_3, v3_4) << '\n'
|
||||
<< "mat4x4<" << typeid(T).name() << ',' << P << ">: " << glm::tmat4x4<T,P>(v4_1, v4_2, v4_3, v4_4) << '\n';
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += test_io_quat<float, glm::highp>(std::cout);
|
||||
Error += test_io_quat<float, glm::highp>(std::wcout);
|
||||
Error += test_io_quat<int, glm::mediump>(std::cout);
|
||||
Error += test_io_quat<int, glm::mediump>(std::wcout);
|
||||
Error += test_io_quat<glm::uint, glm::lowp>(std::cout);
|
||||
Error += test_io_quat<glm::uint, glm::lowp>(std::wcout);
|
||||
|
||||
Error += test_io_vec<float, glm::highp>(std::cout);
|
||||
Error += test_io_vec<float, glm::highp>(std::wcout);
|
||||
Error += test_io_vec<int, glm::mediump>(std::cout);
|
||||
Error += test_io_vec<int, glm::mediump>(std::wcout);
|
||||
Error += test_io_vec<glm::uint, glm::lowp>(std::cout);
|
||||
Error += test_io_vec<glm::uint, glm::lowp>(std::wcout);
|
||||
|
||||
Error += test_io_mat<float, glm::highp>(std::cout, glm::io::column_major);
|
||||
Error += test_io_mat<float, glm::lowp>(std::wcout, glm::io::column_major);
|
||||
Error += test_io_mat<float, glm::highp>(std::cout, glm::io::row_major);
|
||||
Error += test_io_mat<float, glm::lowp>(std::wcout, glm::io::row_major);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
#include <glm/gtx/log_base.hpp>
|
||||
#include <glm/gtc/vec1.hpp>
|
||||
#include <glm/gtc/epsilon.hpp>
|
||||
#include <glm/exponential.hpp>
|
||||
|
||||
namespace test_log
|
||||
{
|
||||
int run()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
{
|
||||
float A = glm::log(10.f, 2.0f);
|
||||
float B = glm::log2(10.f);
|
||||
Error += glm::epsilonEqual(A, B, 0.00001f) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::vec1 A = glm::log(glm::vec1(10.f), glm::vec1(2.0f));
|
||||
glm::vec1 B = glm::log2(glm::vec1(10.f));
|
||||
Error += glm::all(glm::epsilonEqual(A, B, glm::vec1(0.00001f))) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::vec2 A = glm::log(glm::vec2(10.f), glm::vec2(2.0f));
|
||||
glm::vec2 B = glm::log2(glm::vec2(10.f));
|
||||
Error += glm::all(glm::epsilonEqual(A, B, glm::vec2(0.00001f))) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::vec3 A = glm::log(glm::vec3(10.f), glm::vec3(2.0f));
|
||||
glm::vec3 B = glm::log2(glm::vec3(10.f));
|
||||
Error += glm::all(glm::epsilonEqual(A, B, glm::vec3(0.00001f))) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
glm::vec4 A = glm::log(glm::vec4(10.f), glm::vec4(2.0f));
|
||||
glm::vec4 B = glm::log2(glm::vec4(10.f));
|
||||
Error += glm::all(glm::epsilonEqual(A, B, glm::vec4(0.00001f))) ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
}//namespace test_log
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += test_log::run();
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <glm/gtx/matrix_cross_product.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
#include <glm/gtx/matrix_decompose.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
glm::mat4 Matrix(1);
|
||||
|
||||
glm::vec3 Scale;
|
||||
glm::quat Orientation;
|
||||
glm::vec3 Translation;
|
||||
glm::vec3 Skew(1);
|
||||
glm::vec4 Perspective(1);
|
||||
|
||||
glm::decompose(Matrix, Scale, Orientation, Translation, Skew, Perspective);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
#include <glm/gtx/matrix_interpolation.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <glm/gtx/matrix_major_storage.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <glm/gtx/matrix_operation.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
#include <glm/gtx/matrix_query.hpp>
|
||||
|
||||
int test_isNull()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
bool TestA = glm::isNull(glm::mat4(0), 0.00001f);
|
||||
Error += TestA ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_isIdentity()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
{
|
||||
bool TestA = glm::isIdentity(glm::mat2(1), 0.00001f);
|
||||
Error += TestA ? 0 : 1;
|
||||
}
|
||||
{
|
||||
bool TestA = glm::isIdentity(glm::mat3(1), 0.00001f);
|
||||
Error += TestA ? 0 : 1;
|
||||
}
|
||||
{
|
||||
bool TestA = glm::isIdentity(glm::mat4(1), 0.00001f);
|
||||
Error += TestA ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_isNormalized()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
bool TestA = glm::isNormalized(glm::mat4(1), 0.00001f);
|
||||
Error += TestA ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_isOrthogonal()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
bool TestA = glm::isOrthogonal(glm::mat4(1), 0.00001f);
|
||||
Error += TestA ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += test_isNull();
|
||||
Error += test_isIdentity();
|
||||
Error += test_isNormalized();
|
||||
Error += test_isOrthogonal();
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <glm/gtx/matrix_transform_2d.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2013-10-25
|
||||
// Updated : 2013-10-25
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/associated_min_max.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/gtc/type_precision.hpp>
|
||||
#include <glm/gtx/associated_min_max.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <glm/gtx/norm.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <glm/gtx/normal.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <glm/gtx/normalize_dot.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <glm/gtx/number_precision.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <glm/gtx/optimum_pow.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <glm/gtx/orthonormalize.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <glm/gtx/perpendicular.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <glm/gtx/polar_coordinates.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <glm/gtx/projection.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,102 @@
|
||||
#include <glm/gtc/epsilon.hpp>
|
||||
#include <glm/gtc/type_ptr.hpp>
|
||||
#include <glm/gtc/matrix_transform.hpp>
|
||||
#include <glm/gtx/transform.hpp>
|
||||
#include <glm/gtx/quaternion.hpp>
|
||||
#include <glm/gtx/compatibility.hpp>
|
||||
#include <glm/ext.hpp>
|
||||
|
||||
int test_quat_fastMix()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::quat A = glm::angleAxis(0.0f, glm::vec3(0, 0, 1));
|
||||
glm::quat B = glm::angleAxis(glm::pi<float>() * 0.5f, glm::vec3(0, 0, 1));
|
||||
glm::quat C = glm::fastMix(A, B, 0.5f);
|
||||
glm::quat D = glm::angleAxis(glm::pi<float>() * 0.25f, glm::vec3(0, 0, 1));
|
||||
|
||||
Error += glm::epsilonEqual(C.x, D.x, 0.01f) ? 0 : 1;
|
||||
Error += glm::epsilonEqual(C.y, D.y, 0.01f) ? 0 : 1;
|
||||
Error += glm::epsilonEqual(C.z, D.z, 0.01f) ? 0 : 1;
|
||||
Error += glm::epsilonEqual(C.w, D.w, 0.01f) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_quat_shortMix()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
glm::quat A = glm::angleAxis(0.0f, glm::vec3(0, 0, 1));
|
||||
glm::quat B = glm::angleAxis(glm::pi<float>() * 0.5f, glm::vec3(0, 0, 1));
|
||||
glm::quat C = glm::shortMix(A, B, 0.5f);
|
||||
glm::quat D = glm::angleAxis(glm::pi<float>() * 0.25f, glm::vec3(0, 0, 1));
|
||||
|
||||
Error += glm::epsilonEqual(C.x, D.x, 0.01f) ? 0 : 1;
|
||||
Error += glm::epsilonEqual(C.y, D.y, 0.01f) ? 0 : 1;
|
||||
Error += glm::epsilonEqual(C.z, D.z, 0.01f) ? 0 : 1;
|
||||
Error += glm::epsilonEqual(C.w, D.w, 0.01f) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_orientation()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
{
|
||||
glm::quat q(1.0f, 0.0f, 0.0f, 1.0f);
|
||||
float p = glm::roll(q);
|
||||
}
|
||||
|
||||
{
|
||||
glm::quat q(1.0f, 0.0f, 0.0f, 1.0f);
|
||||
float p = glm::pitch(q);
|
||||
}
|
||||
|
||||
{
|
||||
glm::quat q(1.0f, 0.0f, 0.0f, 1.0f);
|
||||
float p = glm::yaw(q);
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_rotation()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
glm::vec3 v(1, 0, 0);
|
||||
glm::vec3 u(0, 1, 0);
|
||||
|
||||
glm::quat Rotation = glm::rotation(v, u);
|
||||
|
||||
float Angle = glm::angle(Rotation);
|
||||
|
||||
Error += glm::abs(Angle - glm::pi<float>() * 0.5f) < glm::epsilon<float>() ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_log()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
glm::quat q;
|
||||
glm::quat p = glm::log(q);
|
||||
glm::quat r = glm::exp(p);
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
Error += test_log();
|
||||
Error += test_rotation();
|
||||
Error += test_quat_fastMix();
|
||||
Error += test_quat_shortMix();
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,99 @@
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2011-05-31
|
||||
// Updated : 2011-05-31
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/gtx/random.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <glm/glm.hpp>
|
||||
#include <glm/gtx/random.hpp>
|
||||
#include <glm/gtx/epsilon.hpp>
|
||||
#include <iostream>
|
||||
|
||||
int test_signedRand1()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
{
|
||||
float ResultFloat = 0.0f;
|
||||
double ResultDouble = 0.0f;
|
||||
for(std::size_t i = 0; i < 100000; ++i)
|
||||
{
|
||||
ResultFloat += glm::signedRand1<float>();
|
||||
ResultDouble += glm::signedRand1<double>();
|
||||
}
|
||||
|
||||
Error += glm::equalEpsilon(ResultFloat, 0.0f, 0.0001f);
|
||||
Error += glm::equalEpsilon(ResultDouble, 0.0, 0.0001);
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_normalizedRand2()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
{
|
||||
std::size_t Max = 100000;
|
||||
float ResultFloat = 0.0f;
|
||||
double ResultDouble = 0.0f;
|
||||
for(std::size_t i = 0; i < Max; ++i)
|
||||
{
|
||||
ResultFloat += glm::length(glm::normalizedRand2<float>());
|
||||
ResultDouble += glm::length(glm::normalizedRand2<double>());
|
||||
}
|
||||
|
||||
Error += glm::equalEpsilon(ResultFloat, float(Max), 0.000001f) ? 0 : 1;
|
||||
Error += glm::equalEpsilon(ResultDouble, double(Max), 0.000001) ? 0 : 1;
|
||||
assert(!Error);
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_normalizedRand3()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
{
|
||||
std::size_t Max = 100000;
|
||||
float ResultFloatA = 0.0f;
|
||||
float ResultFloatB = 0.0f;
|
||||
float ResultFloatC = 0.0f;
|
||||
double ResultDoubleA = 0.0f;
|
||||
double ResultDoubleB = 0.0f;
|
||||
double ResultDoubleC = 0.0f;
|
||||
for(std::size_t i = 0; i < Max; ++i)
|
||||
{
|
||||
ResultFloatA += glm::length(glm::normalizedRand3<float>());
|
||||
ResultDoubleA += glm::length(glm::normalizedRand3<double>());
|
||||
ResultFloatB += glm::length(glm::normalizedRand3(2.0f, 2.0f));
|
||||
ResultDoubleB += glm::length(glm::normalizedRand3(2.0, 2.0));
|
||||
ResultFloatC += glm::length(glm::normalizedRand3(1.0f, 3.0f));
|
||||
ResultDoubleC += glm::length(glm::normalizedRand3(1.0, 3.0));
|
||||
}
|
||||
|
||||
Error += glm::equalEpsilon(ResultFloatA, float(Max), 0.0001f) ? 0 : 1;
|
||||
Error += glm::equalEpsilon(ResultDoubleA, double(Max), 0.0001) ? 0 : 1;
|
||||
Error += glm::equalEpsilon(ResultFloatB, float(Max * 2), 0.0001f) ? 0 : 1;
|
||||
Error += glm::equalEpsilon(ResultDoubleB, double(Max * 2), 0.0001) ? 0 : 1;
|
||||
Error += (ResultFloatC >= float(Max) && ResultFloatC <= float(Max * 3)) ? 0 : 1;
|
||||
Error += (ResultDoubleC >= double(Max) && ResultDoubleC <= double(Max * 3)) ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
Error += test_signedRand1();
|
||||
Error += test_normalizedRand2();
|
||||
Error += test_normalizedRand3();
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
#include <glm/glm.hpp>
|
||||
#include <glm/gtc/epsilon.hpp>
|
||||
|
||||
#if GLM_HAS_RANGE_FOR
|
||||
|
||||
#include <glm/gtx/range.hpp>
|
||||
|
||||
int testVec()
|
||||
{
|
||||
int Error(0);
|
||||
glm::vec3 v(1, 2, 3);
|
||||
|
||||
int count = 0;
|
||||
for(float x : v){ count++; }
|
||||
Error += count == 3 ? 0 : 1;
|
||||
|
||||
for(float& x : v){ x = 0; }
|
||||
Error += glm::all(glm::equal(v, glm::vec3(0, 0, 0))) ? 0 : 1;
|
||||
return Error;
|
||||
}
|
||||
|
||||
int testMat()
|
||||
{
|
||||
int Error(0);
|
||||
glm::mat4x3 m(1);
|
||||
|
||||
int count = 0;
|
||||
for(float x : m){ count++; }
|
||||
Error += count == 12 ? 0 : 1;
|
||||
|
||||
for(float& x : m){ x = 0; }
|
||||
glm::vec4 v(1, 1, 1, 1);
|
||||
Error += glm::all(glm::equal(m*v, glm::vec3(0, 0, 0))) ? 0 : 1;
|
||||
return Error;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
Error += testVec();
|
||||
Error += testMat();
|
||||
return Error;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
int main()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif//GLM_HAS_RANGE_FOR
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <glm/gtx/rotate_normalized_axis.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,75 @@
|
||||
#include <glm/gtc/constants.hpp>
|
||||
#include <glm/gtx/rotate_vector.hpp>
|
||||
|
||||
int test_rotate()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::vec2 A = glm::rotate(glm::vec2(1, 0), glm::pi<float>() * 0.5f);
|
||||
glm::vec3 B = glm::rotate(glm::vec3(1, 0, 0), glm::pi<float>() * 0.5f, glm::vec3(0, 0, 1));
|
||||
glm::vec4 C = glm::rotate(glm::vec4(1, 0, 0, 1), glm::pi<float>() * 0.5f, glm::vec3(0, 0, 1));
|
||||
glm::vec3 D = glm::rotateX(glm::vec3(1, 0, 0), glm::pi<float>() * 0.5f);
|
||||
glm::vec4 E = glm::rotateX(glm::vec4(1, 0, 0, 1), glm::pi<float>() * 0.5f);
|
||||
glm::vec3 F = glm::rotateY(glm::vec3(1, 0, 0), glm::pi<float>() * 0.5f);
|
||||
glm::vec4 G = glm::rotateY(glm::vec4(1, 0, 0, 1), glm::pi<float>() * 0.5f);
|
||||
glm::vec3 H = glm::rotateZ(glm::vec3(1, 0, 0), glm::pi<float>() * 0.5f);
|
||||
glm::vec4 I = glm::rotateZ(glm::vec4(1, 0, 0,1 ), glm::pi<float>() * 0.5f);
|
||||
glm::mat4 O = glm::orientation(glm::normalize(glm::vec3(1)), glm::vec3(0, 0, 1));
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_rotateX()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::vec3 D = glm::rotateX(glm::vec3(1, 0, 0), glm::pi<float>() * 0.5f);
|
||||
glm::vec4 E = glm::rotateX(glm::vec4(1, 0, 0, 1), glm::pi<float>() * 0.5f);
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_rotateY()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::vec3 F = glm::rotateY(glm::vec3(1, 0, 0), glm::pi<float>() * 0.5f);
|
||||
glm::vec4 G = glm::rotateY(glm::vec4(1, 0, 0, 1), glm::pi<float>() * 0.5f);
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
|
||||
int test_rotateZ()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::vec3 H = glm::rotateZ(glm::vec3(1, 0, 0), glm::pi<float>() * 0.5f);
|
||||
glm::vec4 I = glm::rotateZ(glm::vec4(1, 0, 0,1 ), glm::pi<float>() * 0.5f);
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_orientation()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::mat4 O = glm::orientation(glm::normalize(glm::vec3(1)), glm::vec3(0, 0, 1));
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
Error += test_rotate();
|
||||
Error += test_rotateX();
|
||||
Error += test_rotateY();
|
||||
Error += test_rotateZ();
|
||||
Error += test_orientation();
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,34 @@
|
||||
#include <glm/glm.hpp>
|
||||
|
||||
#if GLM_HAS_TEMPLATE_ALIASES && !(GLM_COMPILER & GLM_COMPILER_GCC)
|
||||
#include <glm/gtx/scalar_multiplication.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
glm::vec3 v(0.5, 3.1, -9.1);
|
||||
|
||||
Error += glm::all(glm::equal(v, 1.0 * v)) ? 0 : 1;
|
||||
Error += glm::all(glm::equal(v, 1 * v)) ? 0 : 1;
|
||||
Error += glm::all(glm::equal(v, 1u * v)) ? 0 : 1;
|
||||
|
||||
glm::mat3 m(1, 2, 3, 4, 5, 6, 7, 8, 9);
|
||||
glm::vec3 w = 0.5f * m * v;
|
||||
|
||||
Error += glm::all(glm::equal((m*v)/2, w)) ? 0 : 1;
|
||||
Error += glm::all(glm::equal(m*(v/2), w)) ? 0 : 1;
|
||||
Error += glm::all(glm::equal((m/2)*v, w)) ? 0 : 1;
|
||||
Error += glm::all(glm::equal((0.5*m)*v, w)) ? 0 : 1;
|
||||
Error += glm::all(glm::equal(0.5*(m*v), w)) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
int main()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,170 @@
|
||||
#include <glm/glm.hpp>
|
||||
#include <glm/gtx/scalar_relational.hpp>
|
||||
#include <cstdio>
|
||||
|
||||
int test_lessThan()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += glm::lessThan(0, 1) ? 0 : 1;
|
||||
Error += glm::lessThan(1, 0) ? 1 : 0;
|
||||
Error += glm::lessThan(0, 0) ? 1 : 0;
|
||||
Error += glm::lessThan(1, 1) ? 1 : 0;
|
||||
Error += glm::lessThan(0.0f, 1.0f) ? 0 : 1;
|
||||
Error += glm::lessThan(1.0f, 0.0f) ? 1 : 0;
|
||||
Error += glm::lessThan(0.0f, 0.0f) ? 1 : 0;
|
||||
Error += glm::lessThan(1.0f, 1.0f) ? 1 : 0;
|
||||
Error += glm::lessThan(0.0, 1.0) ? 0 : 1;
|
||||
Error += glm::lessThan(1.0, 0.0) ? 1 : 0;
|
||||
Error += glm::lessThan(0.0, 0.0) ? 1 : 0;
|
||||
Error += glm::lessThan(1.0, 1.0) ? 1 : 0;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_lessThanEqual()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += glm::lessThanEqual(0, 1) ? 0 : 1;
|
||||
Error += glm::lessThanEqual(1, 0) ? 1 : 0;
|
||||
Error += glm::lessThanEqual(0, 0) ? 0 : 1;
|
||||
Error += glm::lessThanEqual(1, 1) ? 0 : 1;
|
||||
Error += glm::lessThanEqual(0.0f, 1.0f) ? 0 : 1;
|
||||
Error += glm::lessThanEqual(1.0f, 0.0f) ? 1 : 0;
|
||||
Error += glm::lessThanEqual(0.0f, 0.0f) ? 0 : 1;
|
||||
Error += glm::lessThanEqual(1.0f, 1.0f) ? 0 : 1;
|
||||
Error += glm::lessThanEqual(0.0, 1.0) ? 0 : 1;
|
||||
Error += glm::lessThanEqual(1.0, 0.0) ? 1 : 0;
|
||||
Error += glm::lessThanEqual(0.0, 0.0) ? 0 : 1;
|
||||
Error += glm::lessThanEqual(1.0, 1.0) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_greaterThan()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += glm::greaterThan(0, 1) ? 1 : 0;
|
||||
Error += glm::greaterThan(1, 0) ? 0 : 1;
|
||||
Error += glm::greaterThan(0, 0) ? 1 : 0;
|
||||
Error += glm::greaterThan(1, 1) ? 1 : 0;
|
||||
Error += glm::greaterThan(0.0f, 1.0f) ? 1 : 0;
|
||||
Error += glm::greaterThan(1.0f, 0.0f) ? 0 : 1;
|
||||
Error += glm::greaterThan(0.0f, 0.0f) ? 1 : 0;
|
||||
Error += glm::greaterThan(1.0f, 1.0f) ? 1 : 0;
|
||||
Error += glm::greaterThan(0.0, 1.0) ? 1 : 0;
|
||||
Error += glm::greaterThan(1.0, 0.0) ? 0 : 1;
|
||||
Error += glm::greaterThan(0.0, 0.0) ? 1 : 0;
|
||||
Error += glm::greaterThan(1.0, 1.0) ? 1 : 0;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_greaterThanEqual()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += glm::greaterThanEqual(0, 1) ? 1 : 0;
|
||||
Error += glm::greaterThanEqual(1, 0) ? 0 : 1;
|
||||
Error += glm::greaterThanEqual(0, 0) ? 0 : 1;
|
||||
Error += glm::greaterThanEqual(1, 1) ? 0 : 1;
|
||||
Error += glm::greaterThanEqual(0.0f, 1.0f) ? 1 : 0;
|
||||
Error += glm::greaterThanEqual(1.0f, 0.0f) ? 0 : 1;
|
||||
Error += glm::greaterThanEqual(0.0f, 0.0f) ? 0 : 1;
|
||||
Error += glm::greaterThanEqual(1.0f, 1.0f) ? 0 : 1;
|
||||
Error += glm::greaterThanEqual(0.0, 1.0) ? 1 : 0;
|
||||
Error += glm::greaterThanEqual(1.0, 0.0) ? 0 : 1;
|
||||
Error += glm::greaterThanEqual(0.0, 0.0) ? 0 : 1;
|
||||
Error += glm::greaterThanEqual(1.0, 1.0) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_equal()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += glm::equal(0, 1) ? 1 : 0;
|
||||
Error += glm::equal(1, 0) ? 1 : 0;
|
||||
Error += glm::equal(0, 0) ? 0 : 1;
|
||||
Error += glm::equal(1, 1) ? 0 : 1;
|
||||
Error += glm::equal(0.0f, 1.0f) ? 1 : 0;
|
||||
Error += glm::equal(1.0f, 0.0f) ? 1 : 0;
|
||||
Error += glm::equal(0.0f, 0.0f) ? 0 : 1;
|
||||
Error += glm::equal(1.0f, 1.0f) ? 0 : 1;
|
||||
Error += glm::equal(0.0, 1.0) ? 1 : 0;
|
||||
Error += glm::equal(1.0, 0.0) ? 1 : 0;
|
||||
Error += glm::equal(0.0, 0.0) ? 0 : 1;
|
||||
Error += glm::equal(1.0, 1.0) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_notEqual()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += glm::notEqual(0, 1) ? 0 : 1;
|
||||
Error += glm::notEqual(1, 0) ? 0 : 1;
|
||||
Error += glm::notEqual(0, 0) ? 1 : 0;
|
||||
Error += glm::notEqual(1, 1) ? 1 : 0;
|
||||
Error += glm::notEqual(0.0f, 1.0f) ? 0 : 1;
|
||||
Error += glm::notEqual(1.0f, 0.0f) ? 0 : 1;
|
||||
Error += glm::notEqual(0.0f, 0.0f) ? 1 : 0;
|
||||
Error += glm::notEqual(1.0f, 1.0f) ? 1 : 0;
|
||||
Error += glm::notEqual(0.0, 1.0) ? 0 : 1;
|
||||
Error += glm::notEqual(1.0, 0.0) ? 0 : 1;
|
||||
Error += glm::notEqual(0.0, 0.0) ? 1 : 0;
|
||||
Error += glm::notEqual(1.0, 1.0) ? 1 : 0;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_any()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += glm::any(true) ? 0 : 1;
|
||||
Error += glm::any(false) ? 1 : 0;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_all()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += glm::all(true) ? 0 : 1;
|
||||
Error += glm::all(false) ? 1 : 0;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_not()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += glm::not_(true) ? 1 : 0;
|
||||
Error += glm::not_(false) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
Error += test_lessThan();
|
||||
Error += test_lessThanEqual();
|
||||
Error += test_greaterThan();
|
||||
Error += test_greaterThanEqual();
|
||||
Error += test_equal();
|
||||
Error += test_notEqual();
|
||||
Error += test_any();
|
||||
Error += test_all();
|
||||
Error += test_not();
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,99 @@
|
||||
#include <glm/vec2.hpp>
|
||||
#include <glm/vec3.hpp>
|
||||
#include <glm/vec4.hpp>
|
||||
#include <glm/gtx/spline.hpp>
|
||||
|
||||
namespace catmullRom
|
||||
{
|
||||
int test()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
glm::vec2 Result2 = glm::catmullRom(
|
||||
glm::vec2(0.0f, 0.0f),
|
||||
glm::vec2(1.0f, 0.0f),
|
||||
glm::vec2(1.0f, 1.0f),
|
||||
glm::vec2(0.0f, 1.0f), 0.5f);
|
||||
|
||||
glm::vec3 Result3 = glm::catmullRom(
|
||||
glm::vec3(0.0f, 0.0f, 0.0f),
|
||||
glm::vec3(1.0f, 0.0f, 0.0f),
|
||||
glm::vec3(1.0f, 1.0f, 0.0f),
|
||||
glm::vec3(0.0f, 1.0f, 0.0f), 0.5f);
|
||||
|
||||
glm::vec4 Result4 = glm::catmullRom(
|
||||
glm::vec4(0.0f, 0.0f, 0.0f, 1.0f),
|
||||
glm::vec4(1.0f, 0.0f, 0.0f, 1.0f),
|
||||
glm::vec4(1.0f, 1.0f, 0.0f, 1.0f),
|
||||
glm::vec4(0.0f, 1.0f, 0.0f, 1.0f), 0.5f);
|
||||
|
||||
return Error;
|
||||
}
|
||||
}//catmullRom
|
||||
|
||||
namespace hermite
|
||||
{
|
||||
int test()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
glm::vec2 Result2 = glm::hermite(
|
||||
glm::vec2(0.0f, 0.0f),
|
||||
glm::vec2(1.0f, 0.0f),
|
||||
glm::vec2(1.0f, 1.0f),
|
||||
glm::vec2(0.0f, 1.0f), 0.5f);
|
||||
|
||||
glm::vec3 Result3 = glm::hermite(
|
||||
glm::vec3(0.0f, 0.0f, 0.0f),
|
||||
glm::vec3(1.0f, 0.0f, 0.0f),
|
||||
glm::vec3(1.0f, 1.0f, 0.0f),
|
||||
glm::vec3(0.0f, 1.0f, 0.0f), 0.5f);
|
||||
|
||||
glm::vec4 Result4 = glm::hermite(
|
||||
glm::vec4(0.0f, 0.0f, 0.0f, 1.0f),
|
||||
glm::vec4(1.0f, 0.0f, 0.0f, 1.0f),
|
||||
glm::vec4(1.0f, 1.0f, 0.0f, 1.0f),
|
||||
glm::vec4(0.0f, 1.0f, 0.0f, 1.0f), 0.5f);
|
||||
|
||||
return Error;
|
||||
}
|
||||
}//catmullRom
|
||||
|
||||
namespace cubic
|
||||
{
|
||||
int test()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
glm::vec2 Result2 = glm::cubic(
|
||||
glm::vec2(0.0f, 0.0f),
|
||||
glm::vec2(1.0f, 0.0f),
|
||||
glm::vec2(1.0f, 1.0f),
|
||||
glm::vec2(0.0f, 1.0f), 0.5f);
|
||||
|
||||
glm::vec3 Result3 = glm::cubic(
|
||||
glm::vec3(0.0f, 0.0f, 0.0f),
|
||||
glm::vec3(1.0f, 0.0f, 0.0f),
|
||||
glm::vec3(1.0f, 1.0f, 0.0f),
|
||||
glm::vec3(0.0f, 1.0f, 0.0f), 0.5f);
|
||||
|
||||
glm::vec4 Result = glm::cubic(
|
||||
glm::vec4(0.0f, 0.0f, 0.0f, 1.0f),
|
||||
glm::vec4(1.0f, 0.0f, 0.0f, 1.0f),
|
||||
glm::vec4(1.0f, 1.0f, 0.0f, 1.0f),
|
||||
glm::vec4(0.0f, 1.0f, 0.0f, 1.0f), 0.5f);
|
||||
|
||||
return Error;
|
||||
}
|
||||
}//catmullRom
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += catmullRom::test();
|
||||
Error += hermite::test();
|
||||
Error += cubic::test();
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,128 @@
|
||||
#include <glm/glm.hpp>
|
||||
#include <glm/gtx/string_cast.hpp>
|
||||
#include <limits>
|
||||
|
||||
int test_string_cast_vector()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
{
|
||||
glm::vec2 A1(1, 2);
|
||||
std::string A2 = glm::to_string(A1);
|
||||
Error += A2 != std::string("vec2(1.000000, 2.000000)") ? 1 : 0;
|
||||
|
||||
glm::vec3 B1(1, 2, 3);
|
||||
std::string B2 = glm::to_string(B1);
|
||||
Error += B2 != std::string("vec3(1.000000, 2.000000, 3.000000)") ? 1 : 0;
|
||||
|
||||
glm::vec4 C1(1, 2, 3, 4);
|
||||
std::string C2 = glm::to_string(C1);
|
||||
Error += C2 != std::string("vec4(1.000000, 2.000000, 3.000000, 4.000000)") ? 1 : 0;
|
||||
|
||||
glm::dvec2 J1(1, 2);
|
||||
std::string J2 = glm::to_string(J1);
|
||||
Error += J2 != std::string("dvec2(1.000000, 2.000000)") ? 1 : 0;
|
||||
|
||||
glm::dvec3 K1(1, 2, 3);
|
||||
std::string K2 = glm::to_string(K1);
|
||||
Error += K2 != std::string("dvec3(1.000000, 2.000000, 3.000000)") ? 1 : 0;
|
||||
|
||||
glm::dvec4 L1(1, 2, 3, 4);
|
||||
std::string L2 = glm::to_string(L1);
|
||||
Error += L2 != std::string("dvec4(1.000000, 2.000000, 3.000000, 4.000000)") ? 1 : 0;
|
||||
}
|
||||
|
||||
{
|
||||
glm::bvec2 M1(false, true);
|
||||
std::string M2 = glm::to_string(M1);
|
||||
Error += M2 != std::string("bvec2(false, true)") ? 1 : 0;
|
||||
|
||||
glm::bvec3 O1(false, true, false);
|
||||
std::string O2 = glm::to_string(O1);
|
||||
Error += O2 != std::string("bvec3(false, true, false)") ? 1 : 0;
|
||||
|
||||
glm::bvec4 P1(false, true, false, true);
|
||||
std::string P2 = glm::to_string(P1);
|
||||
Error += P2 != std::string("bvec4(false, true, false, true)") ? 1 : 0;
|
||||
}
|
||||
|
||||
{
|
||||
glm::ivec2 D1(1, 2);
|
||||
std::string D2 = glm::to_string(D1);
|
||||
Error += D2 != std::string("ivec2(1, 2)") ? 1 : 0;
|
||||
|
||||
glm::ivec3 E1(1, 2, 3);
|
||||
std::string E2 = glm::to_string(E1);
|
||||
Error += E2 != std::string("ivec3(1, 2, 3)") ? 1 : 0;
|
||||
|
||||
glm::ivec4 F1(1, 2, 3, 4);
|
||||
std::string F2 = glm::to_string(F1);
|
||||
Error += F2 != std::string("ivec4(1, 2, 3, 4)") ? 1 : 0;
|
||||
}
|
||||
|
||||
{
|
||||
glm::i8vec2 D1(1, 2);
|
||||
std::string D2 = glm::to_string(D1);
|
||||
Error += D2 != std::string("i8vec2(1, 2)") ? 1 : 0;
|
||||
|
||||
glm::i8vec3 E1(1, 2, 3);
|
||||
std::string E2 = glm::to_string(E1);
|
||||
Error += E2 != std::string("i8vec3(1, 2, 3)") ? 1 : 0;
|
||||
|
||||
glm::i8vec4 F1(1, 2, 3, 4);
|
||||
std::string F2 = glm::to_string(F1);
|
||||
Error += F2 != std::string("i8vec4(1, 2, 3, 4)") ? 1 : 0;
|
||||
}
|
||||
|
||||
{
|
||||
glm::i16vec2 D1(1, 2);
|
||||
std::string D2 = glm::to_string(D1);
|
||||
Error += D2 != std::string("i16vec2(1, 2)") ? 1 : 0;
|
||||
|
||||
glm::i16vec3 E1(1, 2, 3);
|
||||
std::string E2 = glm::to_string(E1);
|
||||
Error += E2 != std::string("i16vec3(1, 2, 3)") ? 1 : 0;
|
||||
|
||||
glm::i16vec4 F1(1, 2, 3, 4);
|
||||
std::string F2 = glm::to_string(F1);
|
||||
Error += F2 != std::string("i16vec4(1, 2, 3, 4)") ? 1 : 0;
|
||||
}
|
||||
|
||||
{
|
||||
glm::i64vec2 D1(1, 2);
|
||||
std::string D2 = glm::to_string(D1);
|
||||
Error += D2 != std::string("i64vec2(1, 2)") ? 1 : 0;
|
||||
|
||||
glm::i64vec3 E1(1, 2, 3);
|
||||
std::string E2 = glm::to_string(E1);
|
||||
Error += E2 != std::string("i64vec3(1, 2, 3)") ? 1 : 0;
|
||||
|
||||
glm::i64vec4 F1(1, 2, 3, 4);
|
||||
std::string F2 = glm::to_string(F1);
|
||||
Error += F2 != std::string("i64vec4(1, 2, 3, 4)") ? 1 : 0;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_string_cast_matrix()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::mat2x2 A1(1.000000, 2.000000, 3.000000, 4.000000);
|
||||
std::string A2 = glm::to_string(A1);
|
||||
Error += A2 != std::string("mat2x2((1.000000, 2.000000), (3.000000, 4.000000))") ? 1 : 0;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error = 0;
|
||||
Error += test_string_cast_vector();
|
||||
Error += test_string_cast_matrix();
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,113 @@
|
||||
#include <glm/gtx/type_aligned.hpp>
|
||||
#include <cstdio>
|
||||
|
||||
int test_decl()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
{
|
||||
struct S1
|
||||
{
|
||||
glm::aligned_vec4 B;
|
||||
};
|
||||
|
||||
struct S2
|
||||
{
|
||||
glm::vec4 B;
|
||||
};
|
||||
|
||||
printf("vec4 - Aligned: %d, unaligned: %d\n", static_cast<int>(sizeof(S1)), static_cast<int>(sizeof(S2)));
|
||||
|
||||
Error += sizeof(S1) >= sizeof(S2) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
struct S1
|
||||
{
|
||||
bool A;
|
||||
glm::vec3 B;
|
||||
};
|
||||
|
||||
struct S2
|
||||
{
|
||||
bool A;
|
||||
glm::aligned_vec3 B;
|
||||
};
|
||||
|
||||
printf("vec3 - Aligned: %d, unaligned: %d\n", static_cast<int>(sizeof(S1)), static_cast<int>(sizeof(S2)));
|
||||
|
||||
Error += sizeof(S1) <= sizeof(S2) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
struct S1
|
||||
{
|
||||
bool A;
|
||||
glm::aligned_vec4 B;
|
||||
};
|
||||
|
||||
struct S2
|
||||
{
|
||||
bool A;
|
||||
glm::vec4 B;
|
||||
};
|
||||
|
||||
printf("vec4 - Aligned: %d, unaligned: %d\n", static_cast<int>(sizeof(S1)), static_cast<int>(sizeof(S2)));
|
||||
|
||||
Error += sizeof(S1) >= sizeof(S2) ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
struct S1
|
||||
{
|
||||
bool A;
|
||||
glm::aligned_dvec4 B;
|
||||
};
|
||||
|
||||
struct S2
|
||||
{
|
||||
bool A;
|
||||
glm::dvec4 B;
|
||||
};
|
||||
|
||||
printf("dvec4 - Aligned: %d, unaligned: %d\n", static_cast<int>(sizeof(S1)), static_cast<int>(sizeof(S2)));
|
||||
|
||||
Error += sizeof(S1) >= sizeof(S2) ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
template <typename genType>
|
||||
void print(genType const & Mat0)
|
||||
{
|
||||
printf("mat4(\n");
|
||||
printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", Mat0[0][0], Mat0[0][1], Mat0[0][2], Mat0[0][3]);
|
||||
printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", Mat0[1][0], Mat0[1][1], Mat0[1][2], Mat0[1][3]);
|
||||
printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", Mat0[2][0], Mat0[2][1], Mat0[2][2], Mat0[2][3]);
|
||||
printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f))\n\n", Mat0[3][0], Mat0[3][1], Mat0[3][2], Mat0[3][3]);
|
||||
}
|
||||
|
||||
int perf_mul()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::mat4 A(1.0f);
|
||||
glm::mat4 B(1.0f);
|
||||
|
||||
glm::mat4 C = A * B;
|
||||
|
||||
print(C);
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += test_decl();
|
||||
Error += perf_mul();
|
||||
|
||||
return Error;
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
#include <glm/vec4.hpp>
|
||||
#include <glm/gtx/type_trait.hpp>
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,58 @@
|
||||
#include <glm/gtc/constants.hpp>
|
||||
#include <glm/gtx/vector_angle.hpp>
|
||||
#include <limits>
|
||||
|
||||
int test_angle()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
float AngleA = glm::angle(glm::vec2(1, 0), glm::normalize(glm::vec2(1, 1)));
|
||||
Error += glm::epsilonEqual(AngleA, glm::pi<float>() * 0.25f, 0.01f) ? 0 : 1;
|
||||
float AngleB = glm::angle(glm::vec3(1, 0, 0), glm::normalize(glm::vec3(1, 1, 0)));
|
||||
Error += glm::epsilonEqual(AngleB, glm::pi<float>() * 0.25f, 0.01f) ? 0 : 1;
|
||||
float AngleC = glm::angle(glm::vec4(1, 0, 0, 0), glm::normalize(glm::vec4(1, 1, 0, 0)));
|
||||
Error += glm::epsilonEqual(AngleC, glm::pi<float>() * 0.25f, 0.01f) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_orientedAngle_vec2()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
float AngleA = glm::orientedAngle(glm::vec2(1, 0), glm::normalize(glm::vec2(1, 1)));
|
||||
Error += AngleA == glm::pi<float>() * 0.25f ? 0 : 1;
|
||||
float AngleB = glm::orientedAngle(glm::vec2(0, 1), glm::normalize(glm::vec2(1, 1)));
|
||||
Error += AngleB == -glm::pi<float>() * 0.25f ? 0 : 1;
|
||||
float AngleC = glm::orientedAngle(glm::normalize(glm::vec2(1, 1)), glm::vec2(0, 1));
|
||||
Error += AngleC == glm::pi<float>() * 0.25f ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_orientedAngle_vec3()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
float AngleA = glm::orientedAngle(glm::vec3(1, 0, 0), glm::normalize(glm::vec3(1, 1, 0)), glm::vec3(0, 0, 1));
|
||||
Error += AngleA == glm::pi<float>() * 0.25f ? 0 : 1;
|
||||
float AngleB = glm::orientedAngle(glm::vec3(0, 1, 0), glm::normalize(glm::vec3(1, 1, 0)), glm::vec3(0, 0, 1));
|
||||
Error += AngleB == -glm::pi<float>() * 0.25f ? 0 : 1;
|
||||
float AngleC = glm::orientedAngle(glm::normalize(glm::vec3(1, 1, 0)), glm::vec3(0, 1, 0), glm::vec3(0, 0, 1));
|
||||
Error += AngleC == glm::pi<float>() * 0.25f ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += test_angle();
|
||||
Error += test_orientedAngle_vec2();
|
||||
Error += test_orientedAngle_vec3();
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,81 @@
|
||||
#include <glm/vec2.hpp>
|
||||
#include <glm/vec3.hpp>
|
||||
#include <glm/vec4.hpp>
|
||||
#include <glm/gtx/vector_query.hpp>
|
||||
|
||||
int test_areCollinear()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
{
|
||||
bool TestA = glm::areCollinear(glm::vec2(-1), glm::vec2(1), 0.00001f);
|
||||
Error += TestA ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
bool TestA = glm::areCollinear(glm::vec3(-1), glm::vec3(1), 0.00001f);
|
||||
Error += TestA ? 0 : 1;
|
||||
}
|
||||
|
||||
{
|
||||
bool TestA = glm::areCollinear(glm::vec4(-1), glm::vec4(1), 0.00001f);
|
||||
Error += TestA ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_areOrthogonal()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
bool TestA = glm::areOrthogonal(glm::vec2(1, 0), glm::vec2(0, 1), 0.00001f);
|
||||
Error += TestA ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_isNormalized()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
bool TestA = glm::isNormalized(glm::vec4(1, 0, 0, 0), 0.00001f);
|
||||
Error += TestA ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_isNull()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
bool TestA = glm::isNull(glm::vec4(0), 0.00001f);
|
||||
Error += TestA ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_areOrthonormal()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
bool TestA = glm::areOrthonormal(glm::vec2(1, 0), glm::vec2(0, 1), 0.00001f);
|
||||
Error += TestA ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += test_areCollinear();
|
||||
Error += test_areOrthogonal();
|
||||
Error += test_isNormalized();
|
||||
Error += test_isNull();
|
||||
Error += test_areOrthonormal();
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,189 @@
|
||||
#include <glm/gtx/wrap.hpp>
|
||||
#include <glm/gtc/epsilon.hpp>
|
||||
|
||||
namespace clamp
|
||||
{
|
||||
int test()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
float A = glm::clamp(0.5f);
|
||||
Error += glm::epsilonEqual(A, 0.5f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float B = glm::clamp(0.0f);
|
||||
Error += glm::epsilonEqual(B, 0.0f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float C = glm::clamp(1.0f);
|
||||
Error += glm::epsilonEqual(C, 1.0f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float D = glm::clamp(-0.5f);
|
||||
Error += glm::epsilonEqual(D, 0.0f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float E = glm::clamp(1.5f);
|
||||
Error += glm::epsilonEqual(E, 1.0f, 0.00001f) ? 0 : 1;
|
||||
|
||||
glm::vec2 K = glm::clamp(glm::vec2(0.5f));
|
||||
Error += glm::all(glm::epsilonEqual(K, glm::vec2(0.5f), glm::vec2(0.00001f))) ? 0 : 1;
|
||||
|
||||
glm::vec3 L = glm::clamp(glm::vec3(0.5f));
|
||||
Error += glm::all(glm::epsilonEqual(L, glm::vec3(0.5f), glm::vec3(0.00001f))) ? 0 : 1;
|
||||
|
||||
glm::vec4 M = glm::clamp(glm::vec4(0.5f));
|
||||
Error += glm::all(glm::epsilonEqual(M, glm::vec4(0.5f), glm::vec4(0.00001f))) ? 0 : 1;
|
||||
|
||||
glm::vec1 N = glm::clamp(glm::vec1(0.5f));
|
||||
Error += glm::all(glm::epsilonEqual(N, glm::vec1(0.5f), glm::vec1(0.00001f))) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
}//namespace clamp
|
||||
|
||||
namespace repeat
|
||||
{
|
||||
int test()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
float A = glm::repeat(0.5f);
|
||||
Error += glm::epsilonEqual(A, 0.5f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float B = glm::repeat(0.0f);
|
||||
Error += glm::epsilonEqual(B, 0.0f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float C = glm::repeat(1.0f);
|
||||
Error += glm::epsilonEqual(C, 0.0f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float D = glm::repeat(-0.5f);
|
||||
Error += glm::epsilonEqual(D, 0.5f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float E = glm::repeat(1.5f);
|
||||
Error += glm::epsilonEqual(E, 0.5f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float F = glm::repeat(0.9f);
|
||||
Error += glm::epsilonEqual(F, 0.9f, 0.00001f) ? 0 : 1;
|
||||
|
||||
glm::vec2 K = glm::repeat(glm::vec2(0.5f));
|
||||
Error += glm::all(glm::epsilonEqual(K, glm::vec2(0.5f), glm::vec2(0.00001f))) ? 0 : 1;
|
||||
|
||||
glm::vec3 L = glm::repeat(glm::vec3(0.5f));
|
||||
Error += glm::all(glm::epsilonEqual(L, glm::vec3(0.5f), glm::vec3(0.00001f))) ? 0 : 1;
|
||||
|
||||
glm::vec4 M = glm::repeat(glm::vec4(0.5f));
|
||||
Error += glm::all(glm::epsilonEqual(M, glm::vec4(0.5f), glm::vec4(0.00001f))) ? 0 : 1;
|
||||
|
||||
glm::vec1 N = glm::repeat(glm::vec1(0.5f));
|
||||
Error += glm::all(glm::epsilonEqual(N, glm::vec1(0.5f), glm::vec1(0.00001f))) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
}//namespace repeat
|
||||
|
||||
namespace mirrorClamp
|
||||
{
|
||||
int test()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
float A = glm::mirrorClamp(0.5f);
|
||||
Error += glm::epsilonEqual(A, 0.5f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float B = glm::mirrorClamp(0.0f);
|
||||
Error += glm::epsilonEqual(B, 0.0f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float C = glm::mirrorClamp(1.1f);
|
||||
Error += glm::epsilonEqual(C, 0.1f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float D = glm::mirrorClamp(-0.5f);
|
||||
Error += glm::epsilonEqual(D, 0.5f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float E = glm::mirrorClamp(1.5f);
|
||||
Error += glm::epsilonEqual(E, 0.5f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float F = glm::mirrorClamp(0.9f);
|
||||
Error += glm::epsilonEqual(F, 0.9f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float G = glm::mirrorClamp(3.1f);
|
||||
Error += glm::epsilonEqual(G, 0.1f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float H = glm::mirrorClamp(-3.1f);
|
||||
Error += glm::epsilonEqual(H, 0.1f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float I = glm::mirrorClamp(-0.9f);
|
||||
Error += glm::epsilonEqual(I, 0.9f, 0.00001f) ? 0 : 1;
|
||||
|
||||
glm::vec2 K = glm::mirrorClamp(glm::vec2(0.5f));
|
||||
Error += glm::all(glm::epsilonEqual(K, glm::vec2(0.5f), glm::vec2(0.00001f))) ? 0 : 1;
|
||||
|
||||
glm::vec3 L = glm::mirrorClamp(glm::vec3(0.5f));
|
||||
Error += glm::all(glm::epsilonEqual(L, glm::vec3(0.5f), glm::vec3(0.00001f))) ? 0 : 1;
|
||||
|
||||
glm::vec4 M = glm::mirrorClamp(glm::vec4(0.5f));
|
||||
Error += glm::all(glm::epsilonEqual(M, glm::vec4(0.5f), glm::vec4(0.00001f))) ? 0 : 1;
|
||||
|
||||
glm::vec1 N = glm::mirrorClamp(glm::vec1(0.5f));
|
||||
Error += glm::all(glm::epsilonEqual(N, glm::vec1(0.5f), glm::vec1(0.00001f))) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
}//namespace mirrorClamp
|
||||
|
||||
namespace mirrorRepeat
|
||||
{
|
||||
int test()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
float A = glm::mirrorRepeat(0.5f);
|
||||
Error += glm::epsilonEqual(A, 0.5f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float B = glm::mirrorRepeat(0.0f);
|
||||
Error += glm::epsilonEqual(B, 0.0f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float C = glm::mirrorRepeat(1.0f);
|
||||
Error += glm::epsilonEqual(C, 1.0f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float D = glm::mirrorRepeat(-0.5f);
|
||||
Error += glm::epsilonEqual(D, 0.5f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float E = glm::mirrorRepeat(1.5f);
|
||||
Error += glm::epsilonEqual(E, 0.5f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float F = glm::mirrorRepeat(0.9f);
|
||||
Error += glm::epsilonEqual(F, 0.9f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float G = glm::mirrorRepeat(3.0f);
|
||||
Error += glm::epsilonEqual(G, 1.0f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float H = glm::mirrorRepeat(-3.0f);
|
||||
Error += glm::epsilonEqual(H, 1.0f, 0.00001f) ? 0 : 1;
|
||||
|
||||
float I = glm::mirrorRepeat(-1.0f);
|
||||
Error += glm::epsilonEqual(I, 1.0f, 0.00001f) ? 0 : 1;
|
||||
|
||||
glm::vec2 K = glm::mirrorRepeat(glm::vec2(0.5f));
|
||||
Error += glm::all(glm::epsilonEqual(K, glm::vec2(0.5f), glm::vec2(0.00001f))) ? 0 : 1;
|
||||
|
||||
glm::vec3 L = glm::mirrorRepeat(glm::vec3(0.5f));
|
||||
Error += glm::all(glm::epsilonEqual(L, glm::vec3(0.5f), glm::vec3(0.00001f))) ? 0 : 1;
|
||||
|
||||
glm::vec4 M = glm::mirrorRepeat(glm::vec4(0.5f));
|
||||
Error += glm::all(glm::epsilonEqual(M, glm::vec4(0.5f), glm::vec4(0.00001f))) ? 0 : 1;
|
||||
|
||||
glm::vec1 N = glm::mirrorRepeat(glm::vec1(0.5f));
|
||||
Error += glm::all(glm::epsilonEqual(N, glm::vec1(0.5f), glm::vec1(0.00001f))) ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
}//namespace mirrorRepeat
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error(0);
|
||||
|
||||
Error += clamp::test();
|
||||
Error += repeat::test();
|
||||
Error += mirrorClamp::test();
|
||||
Error += mirrorRepeat::test();
|
||||
|
||||
return Error;
|
||||
}
|
||||
Reference in New Issue
Block a user