External/cglm
1
0
Fork 0
mirror of https://github.com/recp/cglm.git synced 2025-12-26 10:35:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

changed last parameter to be destination and also removed the euler->mat4->quat test.

Browse Source
This commit is contained in:
John Choi
2023-12-13 08:57:10 -06:00
parent 7e4383cb3d
commit 732a403112
6 changed files with 116 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files

164
test/src/test_euler.c
View File

@@ -8,7 +8,7 @@
#include "test_common.h"
TEST_IMPL(GLM_PREFIX, euler_xyz_quat) {
TEST_IMPL(glm_euler_xyz_quat) {
vec3 axis_x = {1.0f, 0.0f, 0.0f};
vec3 axis_y = {0.0f, 1.0f, 0.0f};
vec3 axis_z = {0.0f, 0.0f, 1.0f};
@@ -21,6 +21,7 @@ TEST_IMPL(GLM_PREFIX, euler_xyz_quat) {
versor expected;
versor result;
versor tmp;
/* 100 randomized tests */
for (int i = 0; i < 100; i++) {
@@ -33,7 +34,7 @@ TEST_IMPL(GLM_PREFIX, euler_xyz_quat) {
/* apply the rotations to a unit quaternion in xyz order */
glm_quat_identity(expected);
versor tmp;
glm_quat_copy(expected, tmp);
glm_quat_mul(tmp, rot_x, expected);
glm_quat_copy(expected, tmp);
@@ -41,18 +42,13 @@ TEST_IMPL(GLM_PREFIX, euler_xyz_quat) {
glm_quat_copy(expected, tmp);
glm_quat_mul(tmp, rot_z, expected);
glm_euler_xyz_quat(result, angles);
glm_euler_xyz_quat(angles, result);
/* verify if the magnitude of the quaternion stays 1 */
ASSERT(test_eq(glm_quat_norm(result), 1.0f))
/* verify that it acts the same as rotating by 3 axis quaternions */
ASSERTIFY(test_assert_quat_eq(result, expected))
/* verify that it acts the same as glm_euler_by_order */
mat4 expected_mat4;
glm_euler_by_order(angles, GLM_EULER_XYZ, expected_mat4);
glm_mat4_quat(expected_mat4, expected);
}
@@ -71,7 +67,7 @@ TEST_IMPL(GLM_PREFIX, euler_xyz_quat) {
/* apply the rotations to a unit quaternion in xyz order */
glm_quat_identity(expected);
versor tmp;
glm_quat_copy(expected, tmp);
glm_quat_mul(tmp, rot_x, expected);
glm_quat_copy(expected, tmp);
@@ -80,32 +76,19 @@ TEST_IMPL(GLM_PREFIX, euler_xyz_quat) {
glm_quat_mul(tmp, rot_z, expected);
/* use my function to get the quaternion */
glm_euler_xyz_quat(result, angles);
glm_euler_xyz_quat(angles, result);
/* verify if the magnitude of the quaternion stays 1 */
ASSERT(test_eq(glm_quat_norm(result), 1.0f))
ASSERTIFY(test_assert_quat_eq(result, expected))
fprintf(stderr, "%f %f %f %f\n",
expected[0], expected[1], expected[2], expected[3]);
/* verify that it acts the same as glm_euler_by_order */
mat4 expected_mat4;
glm_euler_by_order(angles, GLM_EULER_XYZ, expected_mat4);
glm_mat4_quat(expected_mat4, expected);
fprintf(stderr, "%f %f %f %f vs %f %f %f %f\n",
expected[0], expected[1], expected[2], expected[3],
result[0], result[1], result[2], result[3]);
ASSERTIFY(test_assert_quat_eq(result, expected));
}
}
}
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, euler_xzy_quat) {
TEST_IMPL(glm_euler_xzy_quat) {
vec3 axis_x = {1.0f, 0.0f, 0.0f};
vec3 axis_y = {0.0f, 1.0f, 0.0f};
vec3 axis_z = {0.0f, 0.0f, 1.0f};
@@ -118,6 +101,7 @@ TEST_IMPL(GLM_PREFIX, euler_xzy_quat) {
versor expected;
versor result;
versor tmp;
/* 100 randomized tests */
for (int i = 0; i < 100; i++) {
@@ -130,7 +114,7 @@ TEST_IMPL(GLM_PREFIX, euler_xzy_quat) {
/* apply the rotations to a unit quaternion in xzy order */
glm_quat_identity(expected);
versor tmp;
glm_quat_copy(expected, tmp);
glm_quat_mul(tmp, rot_x, expected);
glm_quat_copy(expected, tmp);
@@ -138,20 +122,13 @@ TEST_IMPL(GLM_PREFIX, euler_xzy_quat) {
glm_quat_copy(expected, tmp);
glm_quat_mul(tmp, rot_y, expected);
glm_euler_xzy_quat(result, angles);
glm_euler_xzy_quat(angles, result);
/* verify if the magnitude of the quaternion stays 1 */
ASSERT(test_eq(glm_quat_norm(result), 1.0f))
/* verify that it acts the same as rotating by 3 axis quaternions */
ASSERTIFY(test_assert_quat_eq(result, expected))
/* verify that it acts the same as glm_euler_by_order */
mat4 expected_mat4;
glm_euler_by_order(angles, GLM_EULER_XZY, expected_mat4);
glm_mat4_quat(expected_mat4, expected);
ASSERTIFY(test_assert_quat_eq(result, expected));
}
@@ -170,7 +147,7 @@ TEST_IMPL(GLM_PREFIX, euler_xzy_quat) {
/* apply the rotations to a unit quaternion in xzy order */
glm_quat_identity(expected);
versor tmp;
glm_quat_copy(expected, tmp);
glm_quat_mul(tmp, rot_x, expected);
glm_quat_copy(expected, tmp);
@@ -179,26 +156,19 @@ TEST_IMPL(GLM_PREFIX, euler_xzy_quat) {
glm_quat_mul(tmp, rot_y, expected);
/* use my function to get the quaternion */
glm_euler_xzy_quat(result, angles);
glm_euler_xzy_quat(angles, result);
/* verify if the magnitude of the quaternion stays 1 */
ASSERT(test_eq(glm_quat_norm(result), 1.0f))
ASSERTIFY(test_assert_quat_eq(result, expected))
/* verify that it acts the same as glm_euler_by_order */
mat4 expected_mat4;
glm_euler_by_order(angles, GLM_EULER_XZY, expected_mat4);
glm_mat4_quat(expected_mat4, expected);
ASSERTIFY(test_assert_quat_eq(result, expected));
}
}
}
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, euler_yxz_quat) {
TEST_IMPL(glm_euler_yxz_quat) {
vec3 axis_x = {1.0f, 0.0f, 0.0f};
vec3 axis_y = {0.0f, 1.0f, 0.0f};
vec3 axis_z = {0.0f, 0.0f, 1.0f};
@@ -211,6 +181,7 @@ TEST_IMPL(GLM_PREFIX, euler_yxz_quat) {
versor expected;
versor result;
versor tmp;
/* 100 randomized tests */
for (int i = 0; i < 100; i++) {
@@ -223,7 +194,7 @@ TEST_IMPL(GLM_PREFIX, euler_yxz_quat) {
/* apply the rotations to a unit quaternion in yxz order */
glm_quat_identity(expected);
versor tmp;
glm_quat_copy(expected, tmp);
glm_quat_mul(tmp, rot_y, expected);
glm_quat_copy(expected, tmp);
@@ -231,20 +202,13 @@ TEST_IMPL(GLM_PREFIX, euler_yxz_quat) {
glm_quat_copy(expected, tmp);
glm_quat_mul(tmp, rot_z, expected);
glm_euler_yxz_quat(result, angles);
glm_euler_yxz_quat(angles, result);
/* verify if the magnitude of the quaternion stays 1 */
ASSERT(test_eq(glm_quat_norm(result), 1.0f))
/* verify that it acts the same as rotating by 3 axis quaternions */
ASSERTIFY(test_assert_quat_eq(result, expected))
/* verify that it acts the same as glm_euler_by_order */
mat4 expected_mat4;
glm_euler_by_order(angles, GLM_EULER_YXZ, expected_mat4);
glm_mat4_quat(expected_mat4, expected);
ASSERTIFY(test_assert_quat_eq(result, expected));
}
@@ -263,7 +227,7 @@ TEST_IMPL(GLM_PREFIX, euler_yxz_quat) {
/* apply the rotations to a unit quaternion in yxz order */
glm_quat_identity(expected);
versor tmp;
glm_quat_copy(expected, tmp);
glm_quat_mul(tmp, rot_y, expected);
glm_quat_copy(expected, tmp);
@@ -272,26 +236,19 @@ TEST_IMPL(GLM_PREFIX, euler_yxz_quat) {
glm_quat_mul(tmp, rot_z, expected);
/* use my function to get the quaternion */
glm_euler_yxz_quat(result, angles);
glm_euler_yxz_quat(angles, result);
/* verify if the magnitude of the quaternion stays 1 */
ASSERT(test_eq(glm_quat_norm(result), 1.0f))
ASSERTIFY(test_assert_quat_eq(result, expected))
/* verify that it acts the same as glm_euler_by_order */
mat4 expected_mat4;
glm_euler_by_order(angles, GLM_EULER_YXZ, expected_mat4);
glm_mat4_quat(expected_mat4, expected);
ASSERTIFY(test_assert_quat_eq(result, expected));
}
}
}
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, euler_yzx_quat) {
TEST_IMPL(glm_euler_yzx_quat) {
vec3 axis_x = {1.0f, 0.0f, 0.0f};
vec3 axis_y = {0.0f, 1.0f, 0.0f};
vec3 axis_z = {0.0f, 0.0f, 1.0f};
@@ -304,6 +261,7 @@ TEST_IMPL(GLM_PREFIX, euler_yzx_quat) {
versor expected;
versor result;
versor tmp;
/* 100 randomized tests */
for (int i = 0; i < 100; i++) {
@@ -316,7 +274,7 @@ TEST_IMPL(GLM_PREFIX, euler_yzx_quat) {
/* apply the rotations to a unit quaternion in yzx order */
glm_quat_identity(expected);
versor tmp;
glm_quat_copy(expected, tmp);
glm_quat_mul(tmp, rot_y, expected);
glm_quat_copy(expected, tmp);
@@ -324,20 +282,13 @@ TEST_IMPL(GLM_PREFIX, euler_yzx_quat) {
glm_quat_copy(expected, tmp);
glm_quat_mul(tmp, rot_x, expected);
glm_euler_yzx_quat(result, angles);
glm_euler_yzx_quat(angles, result);
/* verify if the magnitude of the quaternion stays 1 */
ASSERT(test_eq(glm_quat_norm(result), 1.0f))
/* verify that it acts the same as rotating by 3 axis quaternions */
ASSERTIFY(test_assert_quat_eq(result, expected))
/* verify that it acts the same as glm_euler_by_order */
mat4 expected_mat4;
glm_euler_by_order(angles, GLM_EULER_YZX, expected_mat4);
glm_mat4_quat(expected_mat4, expected);
ASSERTIFY(test_assert_quat_eq(result, expected));
}
@@ -356,7 +307,7 @@ TEST_IMPL(GLM_PREFIX, euler_yzx_quat) {
/* apply the rotations to a unit quaternion in yzx order */
glm_quat_identity(expected);
versor tmp;
glm_quat_copy(expected, tmp);
glm_quat_mul(tmp, rot_y, expected);
glm_quat_copy(expected, tmp);
@@ -365,26 +316,19 @@ TEST_IMPL(GLM_PREFIX, euler_yzx_quat) {
glm_quat_mul(tmp, rot_x, expected);
/* use my function to get the quaternion */
glm_euler_yzx_quat(result, angles);
glm_euler_yzx_quat(angles, result);
/* verify if the magnitude of the quaternion stays 1 */
ASSERT(test_eq(glm_quat_norm(result), 1.0f))
ASSERTIFY(test_assert_quat_eq(result, expected))
/* verify that it acts the same as glm_euler_by_order */
mat4 expected_mat4;
glm_euler_by_order(angles, GLM_EULER_YZX, expected_mat4);
glm_mat4_quat(expected_mat4, expected);
ASSERTIFY(test_assert_quat_eq(result, expected));
}
}
}
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, euler_zxy_quat) {
TEST_IMPL(glm_euler_zxy_quat) {
vec3 axis_x = {1.0f, 0.0f, 0.0f};
vec3 axis_y = {0.0f, 1.0f, 0.0f};
vec3 axis_z = {0.0f, 0.0f, 1.0f};
@@ -397,6 +341,7 @@ TEST_IMPL(GLM_PREFIX, euler_zxy_quat) {
versor expected;
versor result;
versor tmp;
/* 100 randomized tests */
for (int i = 0; i < 100; i++) {
@@ -409,7 +354,7 @@ TEST_IMPL(GLM_PREFIX, euler_zxy_quat) {
/* apply the rotations to a unit quaternion in zxy order */
glm_quat_identity(expected);
versor tmp;
glm_quat_copy(expected, tmp);
glm_quat_mul(tmp, rot_z, expected);
glm_quat_copy(expected, tmp);
@@ -417,20 +362,13 @@ TEST_IMPL(GLM_PREFIX, euler_zxy_quat) {
glm_quat_copy(expected, tmp);
glm_quat_mul(tmp, rot_y, expected);
glm_euler_zxy_quat(result, angles);
glm_euler_zxy_quat(angles, result);
/* verify if the magnitude of the quaternion stays 1 */
ASSERT(test_eq(glm_quat_norm(result), 1.0f))
/* verify that it acts the same as rotating by 3 axis quaternions */
ASSERTIFY(test_assert_quat_eq(result, expected))
/* verify that it acts the same as glm_euler_by_order */
mat4 expected_mat4;
glm_euler_by_order(angles, GLM_EULER_ZXY, expected_mat4);
glm_mat4_quat(expected_mat4, expected);
ASSERTIFY(test_assert_quat_eq(result, expected));
}
@@ -449,7 +387,7 @@ TEST_IMPL(GLM_PREFIX, euler_zxy_quat) {
/* apply the rotations to a unit quaternion in zxy order */
glm_quat_identity(expected);
versor tmp;
glm_quat_copy(expected, tmp);
glm_quat_mul(tmp, rot_z, expected);
glm_quat_copy(expected, tmp);
@@ -458,26 +396,19 @@ TEST_IMPL(GLM_PREFIX, euler_zxy_quat) {
glm_quat_mul(tmp, rot_y, expected);
/* use my function to get the quaternion */
glm_euler_zxy_quat(result, angles);
glm_euler_zxy_quat(angles, result);
/* verify if the magnitude of the quaternion stays 1 */
ASSERT(test_eq(glm_quat_norm(result), 1.0f))
ASSERTIFY(test_assert_quat_eq(result, expected))
/* verify that it acts the same as glm_euler_by_order */
mat4 expected_mat4;
glm_euler_by_order(angles, GLM_EULER_ZXY, expected_mat4);
glm_mat4_quat(expected_mat4, expected);
ASSERTIFY(test_assert_quat_eq(result, expected));
}
}
}
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, euler_zyx_quat) {
TEST_IMPL(glm_euler_zyx_quat) {
vec3 axis_x = {1.0f, 0.0f, 0.0f};
vec3 axis_y = {0.0f, 1.0f, 0.0f};
vec3 axis_z = {0.0f, 0.0f, 1.0f};
@@ -491,6 +422,8 @@ TEST_IMPL(GLM_PREFIX, euler_zyx_quat) {
versor expected;
versor result;
versor tmp;
/* 100 randomized tests */
for (int i = 0; i < 100; i++) {
test_rand_vec3(angles);
@@ -502,7 +435,7 @@ TEST_IMPL(GLM_PREFIX, euler_zyx_quat) {
/* apply the rotations to a unit quaternion in zyx order */
glm_quat_identity(expected);
versor tmp;
glm_quat_copy(expected, tmp);
glm_quat_mul(tmp, rot_z, expected);
glm_quat_copy(expected, tmp);
@@ -510,20 +443,13 @@ TEST_IMPL(GLM_PREFIX, euler_zyx_quat) {
glm_quat_copy(expected, tmp);
glm_quat_mul(tmp, rot_x, expected);
glm_euler_zyx_quat(result, angles);
glm_euler_zyx_quat(angles, result);
/* verify if the magnitude of the quaternion stays 1 */
ASSERT(test_eq(glm_quat_norm(result), 1.0f))
/* verify that it acts the same as rotating by 3 axis quaternions */
ASSERTIFY(test_assert_quat_eq(result, expected))
/* verify that it acts the same as glm_euler_by_order */
mat4 expected_mat4;
glm_euler_by_order(angles, GLM_EULER_ZYX, expected_mat4);
glm_mat4_quat(expected_mat4, expected);
ASSERTIFY(test_assert_quat_eq(result, expected));
}
@@ -542,7 +468,7 @@ TEST_IMPL(GLM_PREFIX, euler_zyx_quat) {
/* apply the rotations to a unit quaternion in xyz order */
glm_quat_identity(expected);
versor tmp;
glm_quat_copy(expected, tmp);
glm_quat_mul(tmp, rot_z, expected);
glm_quat_copy(expected, tmp);
@@ -551,19 +477,12 @@ TEST_IMPL(GLM_PREFIX, euler_zyx_quat) {
glm_quat_mul(tmp, rot_x, expected);
/* use my function to get the quaternion */
glm_euler_zyx_quat(result, angles);
glm_euler_zyx_quat(angles, result);
/* verify if the magnitude of the quaternion stays 1 */
ASSERT(test_eq(glm_quat_norm(result), 1.0f))
ASSERTIFY(test_assert_quat_eq(result, expected))
/* verify that it acts the same as glm_euler_by_order */
mat4 expected_mat4;
glm_euler_by_order(angles, GLM_EULER_ZYX, expected_mat4);
glm_mat4_quat(expected_mat4, expected);
ASSERTIFY(test_assert_quat_eq(result, expected));
}
}
}
@@ -604,15 +523,6 @@ TEST_IMPL(euler) {
/* matrices must be equal */
glmc_euler_xyz(outAngles, rot2);
ASSERTIFY(test_assert_mat4_eq(rot1, rot2))
/* somehow when I try to make tests outside of this thing,
it won't work. So they stay here for now */
ASSERTIFY(test_GLM_PREFIXeuler_xyz_quat());
ASSERTIFY(test_GLM_PREFIXeuler_xzy_quat());
ASSERTIFY(test_GLM_PREFIXeuler_yxz_quat());
ASSERTIFY(test_GLM_PREFIXeuler_yzx_quat());
ASSERTIFY(test_GLM_PREFIXeuler_zxy_quat());
ASSERTIFY(test_GLM_PREFIXeuler_zyx_quat());
TEST_SUCCESS
}

9
test/tests.h
View File

@@ -360,13 +360,13 @@ TEST_DECLARE(glmc_plane_normalize)
TEST_DECLARE(clamp)
/* euler */
TEST_DECLARE(euler)
TEST_DECLARE(glm_euler_xyz_quat)
TEST_DECLARE(glm_euler_xzy_quat)
TEST_DECLARE(glm_euler_yxz_quat)
TEST_DECLARE(glm_euler_yzx_quat)
TEST_DECLARE(glm_euler_zxy_quat)
TEST_DECLARE(glm_euler_zyx_quat)
TEST_DECLARE(euler)
/* ray */
TEST_DECLARE(glm_ray_triangle)
@@ -1361,8 +1361,13 @@ TEST_LIST {
TEST_ENTRY(clamp)
/* euler */
TEST_ENTRY(glm_euler_xyz_quat)
TEST_ENTRY(glm_euler_xzy_quat)
TEST_ENTRY(glm_euler_yxz_quat)
TEST_ENTRY(glm_euler_yzx_quat)
TEST_ENTRY(glm_euler_zxy_quat)
TEST_ENTRY(glm_euler_zyx_quat)
TEST_ENTRY(euler)
/* ray */
TEST_ENTRY(glm_ray_triangle)