External/cglm
1
0
Fork 0
mirror of https://github.com/recp/cglm.git synced 2025-12-25 12:55:04 +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

12
include/cglm/call/euler.h
View File

@@ -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

72
include/cglm/euler.h
View File

@@ -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;
}

36
include/cglm/struct/euler.h
View File

@@ -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;
}

24
src/euler.c
View File

@@ -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);
}

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)