diff --git a/include/cglm/call/euler.h b/include/cglm/call/euler.h index 52dd1ef..182bcbb 100644 --- a/include/cglm/call/euler.h +++ b/include/cglm/call/euler.h @@ -51,27 +51,27 @@ glmc_euler_by_order(vec3 angles, glm_euler_seq axis, mat4 dest); CGLM_EXPORT void -glmc_euler_xyz_quat(versor q, vec3 angles); +glmc_euler_xyz_quat(vec3 angles, versor dest); CGLM_EXPORT void -glmc_euler_xzy_quat(versor q, vec3 angles); +glmc_euler_xzy_quat(vec3 angles, versor dest); CGLM_EXPORT void -glmc_euler_yxz_quat(versor q, vec3 angles); +glmc_euler_yxz_quat(vec3 angles, versor dest); CGLM_EXPORT void -glmc_euler_yzx_quat(versor q, vec3 angles); +glmc_euler_yzx_quat(vec3 angles, versor dest); CGLM_EXPORT void -glmc_euler_zxy_quat(versor q, vec3 angles); +glmc_euler_zxy_quat(vec3 angles, versor dest); CGLM_EXPORT void -glmc_euler_zyx_quat(versor q, vec3 angles); +glmc_euler_zyx_quat(vec3 angles, versor dest); #ifdef __cplusplus diff --git a/include/cglm/euler.h b/include/cglm/euler.h index d7dbaf4..8a4acfd 100644 --- a/include/cglm/euler.h +++ b/include/cglm/euler.h @@ -30,12 +30,12 @@ CGLM_INLINE void glm_euler_by_order(vec3 angles, glm_euler_seq ord, mat4 dest); - CGLM_INLINE void glm_euler_xyz_quat(versor q, vec3 angles); - CGLM_INLINE void glm_euler_xzy_quat(versor q, vec3 angles); - CGLM_INLINE void glm_euler_yxz_quat(versor q, vec3 angles); - CGLM_INLINE void glm_euler_yzx_quat(versor q, vec3 angles); - CGLM_INLINE void glm_euler_zxy_quat(versor q, vec3 angles); - CGLM_INLINE void glm_euler_zyx_quat(versor q, vec3 angles); + CGLM_INLINE void glm_euler_xyz_quat(vec3 angles, versor dest); + CGLM_INLINE void glm_euler_xzy_quat(vec3 angles, versor dest); + CGLM_INLINE void glm_euler_yxz_quat(vec3 angles, versor dest); + CGLM_INLINE void glm_euler_yzx_quat(vec3 angles, versor dest); + CGLM_INLINE void glm_euler_zxy_quat(vec3 angles, versor dest); + CGLM_INLINE void glm_euler_zyx_quat(vec3 angles, versor dest); */ #ifndef cglm_euler_h @@ -464,7 +464,7 @@ glm_euler_by_order(vec3 angles, glm_euler_seq ord, mat4 dest) { */ CGLM_INLINE void -glm_euler_xyz_quat(versor q, vec3 angles) { +glm_euler_xyz_quat(vec3 angles, versor dest) { float xc, yc, zc, xs, ys, zs; @@ -472,10 +472,10 @@ glm_euler_xyz_quat(versor q, vec3 angles) { ys = sinf(angles[1] * 0.5f); yc = cosf(angles[1] * 0.5f); zs = sinf(angles[2] * 0.5f); zc = cosf(angles[2] * 0.5f); - q[0] = xc * ys * zs + xs * yc * zc; - q[1] = xc * ys * zc - xs * yc * zs; - q[2] = xc * yc * zs + xs * ys * zc; - q[3] = xc * yc * zc - xs * ys * zs; + dest[0] = xc * ys * zs + xs * yc * zc; + dest[1] = xc * ys * zc - xs * yc * zs; + dest[2] = xc * yc * zs + xs * ys * zc; + dest[3] = xc * yc * zc - xs * ys * zs; } @@ -488,7 +488,7 @@ glm_euler_xyz_quat(versor q, vec3 angles) { */ CGLM_INLINE void -glm_euler_xzy_quat(versor q, vec3 angles) { +glm_euler_xzy_quat(vec3 angles, versor dest) { float xc, yc, zc, xs, ys, zs; @@ -496,10 +496,10 @@ glm_euler_xzy_quat(versor q, vec3 angles) { ys = sinf(angles[1] * 0.5f); yc = cosf(angles[1] * 0.5f); zs = sinf(angles[2] * 0.5f); zc = cosf(angles[2] * 0.5f); - q[0] = -xc * zs * ys + xs * zc * yc; - q[1] = xc * zc * ys - xs * zs * yc; - q[2] = xc * zs * yc + xs * zc * ys; - q[3] = xc * zc * yc + xs * zs * ys; + dest[0] = -xc * zs * ys + xs * zc * yc; + dest[1] = xc * zc * ys - xs * zs * yc; + dest[2] = xc * zs * yc + xs * zc * ys; + dest[3] = xc * zc * yc + xs * zs * ys; } @@ -512,7 +512,7 @@ glm_euler_xzy_quat(versor q, vec3 angles) { */ CGLM_INLINE void -glm_euler_yxz_quat(versor q, vec3 angles) { +glm_euler_yxz_quat(vec3 angles, versor dest) { float xc, yc, zc, xs, ys, zs; @@ -520,10 +520,10 @@ glm_euler_yxz_quat(versor q, vec3 angles) { ys = sinf(angles[1] * 0.5f); yc = cosf(angles[1] * 0.5f); zs = sinf(angles[2] * 0.5f); zc = cosf(angles[2] * 0.5f); - q[0] = yc * xs * zc + ys * xc * zs; - q[1] = -yc * xs * zs + ys * xc * zc; - q[2] = yc * xc * zs - ys * xs * zc; - q[3] = yc * xc * zc + ys * xs * zs; + dest[0] = yc * xs * zc + ys * xc * zs; + dest[1] = -yc * xs * zs + ys * xc * zc; + dest[2] = yc * xc * zs - ys * xs * zc; + dest[3] = yc * xc * zc + ys * xs * zs; } /*! @@ -535,7 +535,7 @@ glm_euler_yxz_quat(versor q, vec3 angles) { */ CGLM_INLINE void -glm_euler_yzx_quat(versor q, vec3 angles) { +glm_euler_yzx_quat(vec3 angles, versor dest) { float xc, yc, zc, xs, ys, zs; @@ -543,10 +543,10 @@ glm_euler_yzx_quat(versor q, vec3 angles) { ys = sinf(angles[1] * 0.5f); yc = cosf(angles[1] * 0.5f); zs = sinf(angles[2] * 0.5f); zc = cosf(angles[2] * 0.5f); - q[0] = yc * zc * xs + ys * zs * xc; - q[1] = yc * zs * xs + ys * zc * xc; - q[2] = yc * zs * xc - ys * zc * xs; - q[3] = yc * zc * xc - ys * zs * xs; + dest[0] = yc * zc * xs + ys * zs * xc; + dest[1] = yc * zs * xs + ys * zc * xc; + dest[2] = yc * zs * xc - ys * zc * xs; + dest[3] = yc * zc * xc - ys * zs * xs; } @@ -559,7 +559,7 @@ glm_euler_yzx_quat(versor q, vec3 angles) { */ CGLM_INLINE void -glm_euler_zxy_quat(versor q, vec3 angles) { +glm_euler_zxy_quat(vec3 angles, versor dest) { float xc, yc, zc, xs, ys, zs; @@ -567,10 +567,10 @@ glm_euler_zxy_quat(versor q, vec3 angles) { ys = sinf(angles[1] * 0.5f); yc = cosf(angles[1] * 0.5f); zs = sinf(angles[2] * 0.5f); zc = cosf(angles[2] * 0.5f); - q[0] = zc * xs * yc - zs * xc * ys; - q[1] = zc * xc * ys + zs * xs * yc; - q[2] = zc * xs * ys + zs * xc * yc; - q[3] = zc * xc * yc - zs * xs * ys; + dest[0] = zc * xs * yc - zs * xc * ys; + dest[1] = zc * xc * ys + zs * xs * yc; + dest[2] = zc * xs * ys + zs * xc * yc; + dest[3] = zc * xc * yc - zs * xs * ys; } /*! @@ -582,7 +582,7 @@ glm_euler_zxy_quat(versor q, vec3 angles) { */ CGLM_INLINE void -glm_euler_zyx_quat(versor q, vec3 angles) { +glm_euler_zyx_quat(vec3 angles, versor dest) { float xc, yc, zc, xs, ys, zs; @@ -590,10 +590,10 @@ glm_euler_zyx_quat(versor q, vec3 angles) { ys = sinf(angles[1] * 0.5f); yc = cosf(angles[1] * 0.5f); zs = sinf(angles[2] * 0.5f); zc = cosf(angles[2] * 0.5f); - q[0] = zc * yc * xs - zs * ys * xc; - q[1] = zc * ys * xc + zs * yc * xs; - q[2] = -zc * ys * xs + zs * yc * xc; - q[3] = zc * yc * xc + zs * ys * xs; + dest[0] = zc * yc * xs - zs * ys * xc; + dest[1] = zc * ys * xc + zs * yc * xs; + dest[2] = -zc * ys * xs + zs * yc * xc; + dest[3] = zc * yc * xc + zs * ys * xs; } diff --git a/include/cglm/struct/euler.h b/include/cglm/struct/euler.h index 1f73cde..7b75946 100644 --- a/include/cglm/struct/euler.h +++ b/include/cglm/struct/euler.h @@ -26,12 +26,12 @@ CGLM_INLINE mat4s glms_euler_zxy(vec3s angles) CGLM_INLINE mat4s glms_euler_zyx(vec3s angles) CGLM_INLINE mat4s glms_euler_by_order(vec3s angles, glm_euler_seq ord) - CGLM_INLINE versors glms_euler_xyz_quat(versors q, vec3s angles) - CGLM_INLINE versors glms_euler_xzy_quat(versors q, vec3s angles) - CGLM_INLINE versors glms_euler_yxz_quat(versors q, vec3s angles) - CGLM_INLINE versors glms_euler_yzx_quat(versors q, vec3s angles) - CGLM_INLINE versors glms_euler_zxy_quat(versors q, vec3s angles) - CGLM_INLINE versors glms_euler_zyx_quat(versors q, vec3s angles) + CGLM_INLINE versors glms_euler_xyz_quat(vec3s angles) + CGLM_INLINE versors glms_euler_xzy_quat(vec3s angles) + CGLM_INLINE versors glms_euler_yxz_quat(vec3s angles) + CGLM_INLINE versors glms_euler_yzx_quat(vec3s angles) + CGLM_INLINE versors glms_euler_zxy_quat(vec3s angles) + CGLM_INLINE versors glms_euler_zyx_quat(vec3s angles) */ #ifndef cglms_euler_h @@ -164,9 +164,9 @@ glms_euler_by_order(vec3s angles, glm_euler_seq ord) { */ CGLM_INLINE versors -glms_euler_xyz_quat(versors q, vec3s angles) { +glms_euler_xyz_quat(vec3s angles) { versors dest; - glm_euler_xyz_quat(dest.raw, angles.raw); + glm_euler_xyz_quat(angles.raw, dest.raw); return dest; } @@ -179,9 +179,9 @@ glms_euler_xyz_quat(versors q, vec3s angles) { */ CGLM_INLINE versors -glms_euler_xzy_quat(versors q, vec3s angles) { +glms_euler_xzy_quat(vec3s angles) { versors dest; - glm_euler_xzy_quat(dest.raw, angles.raw); + glm_euler_xzy_quat(angles.raw, dest.raw); return dest; } @@ -194,9 +194,9 @@ glms_euler_xzy_quat(versors q, vec3s angles) { */ CGLM_INLINE versors -glms_euler_yxz_quat(versors q, vec3s angles) { +glms_euler_yxz_quat(vec3s angles) { versors dest; - glm_euler_yxz_quat(dest.raw, angles.raw); + glm_euler_yxz_quat(angles.raw, dest.raw); return dest; } @@ -209,9 +209,9 @@ glms_euler_yxz_quat(versors q, vec3s angles) { */ CGLM_INLINE versors -glms_euler_yzx_quat(versors q, vec3s angles) { +glms_euler_yzx_quat(vec3s angles) { versors dest; - glm_euler_yzx_quat(dest.raw, angles.raw); + glm_euler_yzx_quat(angles.raw, dest.raw); return dest; } @@ -224,9 +224,9 @@ glms_euler_yzx_quat(versors q, vec3s angles) { */ CGLM_INLINE versors -glms_euler_zxy_quat(versors q, vec3s angles) { +glms_euler_zxy_quat(vec3s angles) { versors dest; - glm_euler_zxy_quat(dest.raw, angles.raw); + glm_euler_zxy_quat(angles.raw, dest.raw); return dest; } @@ -239,9 +239,9 @@ glms_euler_zxy_quat(versors q, vec3s angles) { */ CGLM_INLINE versors -glms_euler_zyx_quat(versors q, vec3s angles) { +glms_euler_zyx_quat(vec3s angles) { versors dest; - glm_euler_zyx_quat(dest.raw, angles.raw); + glm_euler_zyx_quat(angles.raw, dest.raw); return dest; } diff --git a/src/euler.c b/src/euler.c index 53c0bf5..2b0fe0f 100644 --- a/src/euler.c +++ b/src/euler.c @@ -64,37 +64,37 @@ glmc_euler_by_order(vec3 angles, glm_euler_seq axis, mat4 dest) { CGLM_EXPORT void -glmc_euler_xyz_quat(versor q, vec3 angles) { - glm_euler_xyz_quat(q, angles); +glmc_euler_xyz_quat(vec3 angles, versor dest) { + glm_euler_xyz_quat(angles, dest); } CGLM_EXPORT void -glmc_euler_xzy_quat(versor q, vec3 angles) { - glm_euler_xzy_quat(q, angles); +glmc_euler_xzy_quat(vec3 angles, versor dest) { + glm_euler_xzy_quat(angles, dest); } CGLM_EXPORT void -glmc_euler_yxz_quat(versor q, vec3 angles) { - glm_euler_yxz_quat(q, angles); +glmc_euler_yxz_quat(vec3 angles, versor dest) { + glm_euler_yxz_quat(angles, dest); } CGLM_EXPORT void -glmc_euler_yzx_quat(versor q, vec3 angles) { - glm_euler_yzx_quat(q, angles); +glmc_euler_yzx_quat(vec3 angles, versor dest) { + glm_euler_yzx_quat(angles, dest); } CGLM_EXPORT void -glmc_euler_zxy_quat(versor q, vec3 angles) { - glm_euler_zxy_quat(q, angles); +glmc_euler_zxy_quat(vec3 angles, versor dest) { + glm_euler_zxy_quat(angles, dest); } CGLM_EXPORT void -glmc_euler_zyx_quat(versor q, vec3 angles) { - glm_euler_zyx_quat(q, angles); +glmc_euler_zyx_quat(vec3 angles, versor dest) { + glm_euler_zyx_quat(angles, dest); } diff --git a/test/src/test_euler.c b/test/src/test_euler.c index d12f6cc..a2f02d9 100644 --- a/test/src/test_euler.c +++ b/test/src/test_euler.c @@ -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 } diff --git a/test/tests.h b/test/tests.h index addc2ef..c707ce9 100644 --- a/test/tests.h +++ b/test/tests.h @@ -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)