Files
cglm/test/src/test_quat.h

1596 lines
41 KiB
C

/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#include "test_common.h"
#ifndef CGLM_TEST_QUAT_ONCE
#define CGLM_TEST_QUAT_ONCE
/* Macros */
TEST_IMPL(MACRO_GLM_QUAT_IDENTITY_INIT) {
versor v = GLM_QUAT_IDENTITY_INIT;
ASSERT(test_eq(v[0], 0.0f))
ASSERT(test_eq(v[1], 0.0f))
ASSERT(test_eq(v[2], 0.0f))
ASSERT(test_eq(v[3], 1.0f))
TEST_SUCCESS
}
TEST_IMPL(MACRO_GLM_QUAT_IDENTITY) {
ASSERT(test_eq(GLM_QUAT_IDENTITY[0], 0.0f))
ASSERT(test_eq(GLM_QUAT_IDENTITY[1], 0.0f))
ASSERT(test_eq(GLM_QUAT_IDENTITY[2], 0.0f))
ASSERT(test_eq(GLM_QUAT_IDENTITY[3], 1.0f))
TEST_SUCCESS
}
#endif /* CGLM_TEST_QUAT_ONCE */
TEST_IMPL(GLM_PREFIX, quat_identity) {
versor a = GLM_QUAT_IDENTITY_INIT;
versor b = GLM_QUAT_IDENTITY_INIT;
versor c;
mat4 r;
GLM(quat_identity)(c);
ASSERTIFY(test_assert_quat_eq_identity(a))
ASSERTIFY(test_assert_quat_eq_identity(b))
ASSERTIFY(test_assert_quat_eq_identity(c))
glm_quat_identity(c);
ASSERT(test_eq(glm_quat_real(c), cosf(glm_rad(0.0f) * 0.5f)))
glm_quat_mat4(c, r);
ASSERTIFY(test_assert_mat4_eq2(r, GLM_MAT4_IDENTITY, 0.000009f))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_identity_array) {
size_t i, count;
versor quats[4] = {
{1.0f, 2.0f, 3.0f, 4.0f},
{1.0f, 2.0f, 3.0f, 4.0f},
{1.0f, 2.0f, 3.0f, 4.0f},
{1.0f, 2.0f, 3.0f, 4.0f},
};
count = 4;
GLM(quat_identity_array)(quats, count);
for (i = 0; i < count; i++) {
ASSERTIFY(test_assert_quat_eq_identity(quats[i]))
}
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_init) {
versor q1 = {1.0f, 2.0f, 3.0f, 4.0f};
versor q2 = {1.0f, 2.0f, 3.0f, 4.0f};
versor q3 = {1.0f, 2.0f, 3.0f, 4.0f};
GLM(quat_init)(q1, 10.0f, 11.0f, 12.0f, 13.0f);
GLM(quat_init)(q2, 100.0f, 110.0f, 120.0f, 130.0f);
GLM(quat_init)(q3, 1000.0f, 1100.0f, 1200.0f, 1300.0f);
ASSERT(q1[0] == 10.0f)
ASSERT(q1[1] == 11.0f)
ASSERT(q1[2] == 12.0f)
ASSERT(q1[3] == 13.0f)
ASSERT(q2[0] == 100.0f)
ASSERT(q2[1] == 110.0f)
ASSERT(q2[2] == 120.0f)
ASSERT(q2[3] == 130.0f)
ASSERT(q3[0] == 1000.0f)
ASSERT(q3[1] == 1100.0f)
ASSERT(q3[2] == 1200.0f)
ASSERT(q3[3] == 1300.0f)
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, euler_xyz_quat) {
for (int i = 0; i < 100; i++) {
/*random angles for testing*/
vec3 angles;
/*quaternion representations for rotations*/
versor rot_x = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_y = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_z = {0.0f, 0.0f, 0.0f, 1.0f};
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};
versor expected = {0.0f, 0.0f, 0.0f, 1.0f};
versor result;
test_rand_vec3(angles);
/*create the rotation quaternions using the angles and axises*/
glm_quatv(rot_x, angles[0], axis_x);
glm_quatv(rot_y, angles[1], axis_y);
glm_quatv(rot_z, angles[2], axis_z);
/*apply the rotations to a unit quaternion in xyz order*/
glm_quat_mul(rot_x, expected, expected);
glm_quat_mul(rot_y, expected, expected);
glm_quat_mul(rot_z, expected, expected);
/*use my function to get the quaternion*/
glm_euler_xyz_quat(result, angles);
/*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))
}
/*Start gimbal lock tests*/
for (float x = -90.0f; x <= 90.0f; x += 90.0f) {
for (float y = -90.0f; y <= 90.0f; y += 90.0f) {
for (float z = -90.0f; z <= 90.0f; z += 90.0f) {
/* angles that will cause gimbal lock*/
vec3 angles = {x, y, z};
/*quaternion representations for rotations*/
versor rot_x = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_y = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_z = {0.0f, 0.0f, 0.0f, 1.0f};
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};
versor expected = {0.0f, 0.0f, 0.0f, 1.0f};
versor result;
/*create the rotation quaternions using the angles and axises*/
glm_quatv(rot_x, angles[0], axis_x);
glm_quatv(rot_y, angles[1], axis_y);
glm_quatv(rot_z, angles[2], axis_z);
/*apply the rotations to a unit quaternion in xyz order*/
glm_quat_mul(rot_x, expected, expected);
glm_quat_mul(rot_y, expected, expected);
glm_quat_mul(rot_z, expected, expected);
/*use my function to get the quaternion*/
glm_euler_xyz_quat(result, angles);
/*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))
}
}
}
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, euler_xzy_quat) {
for (int i = 0; i < 100; i++) {
/*random angles for testing*/
vec3 angles;
/*quaternion representations for rotations*/
versor rot_x = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_y = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_z = {0.0f, 0.0f, 0.0f, 1.0f};
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};
versor expected = {0.0f, 0.0f, 0.0f, 1.0f};
versor result;
test_rand_vec3(angles);
/*create the rotation quaternions using the angles and axises*/
glm_quatv(rot_x, angles[0], axis_x);
glm_quatv(rot_y, angles[1], axis_y);
glm_quatv(rot_z, angles[2], axis_z);
/*apply the rotations to a unit quaternion in xzy order*/
glm_quat_mul(rot_x, expected, expected);
glm_quat_mul(rot_z, expected, expected);
glm_quat_mul(rot_y, expected, expected);
/*use my function to get the quaternion*/
glm_euler_xzy_quat(result, angles);
/*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))
}
/*Start gimbal lock tests*/
for (float x = -90.0f; x <= 90.0f; x += 90.0f) {
for (float y = -90.0f; y <= 90.0f; y += 90.0f) {
for (float z = -90.0f; z <= 90.0f; z += 90.0f) {
/* angles that will cause gimbal lock*/
vec3 angles = {x, y, z};
/*quaternion representations for rotations*/
versor rot_x = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_y = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_z = {0.0f, 0.0f, 0.0f, 1.0f};
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};
versor expected = {0.0f, 0.0f, 0.0f, 1.0f};
versor result;
/*create the rotation quaternions using the angles and axises*/
glm_quatv(rot_x, angles[0], axis_x);
glm_quatv(rot_y, angles[1], axis_y);
glm_quatv(rot_z, angles[2], axis_z);
/*apply the rotations to a unit quaternion in xyz order*/
glm_quat_mul(rot_x, expected, expected);
glm_quat_mul(rot_z, expected, expected);
glm_quat_mul(rot_y, expected, expected);
/*use my function to get the quaternion*/
glm_euler_xzy_quat(result, angles);
/*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))
}
}
}
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, euler_yxz_quat) {
for (int i = 0; i < 100; i++) {
/*random angles for testing*/
vec3 angles;
/*quaternion representations for rotations*/
versor rot_x = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_y = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_z = {0.0f, 0.0f, 0.0f, 1.0f};
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};
versor expected = {0.0f, 0.0f, 0.0f, 1.0f};
versor result;
test_rand_vec3(angles);
/*create the rotation quaternions using the angles and axises*/
glm_quatv(rot_x, angles[0], axis_x);
glm_quatv(rot_y, angles[1], axis_y);
glm_quatv(rot_z, angles[2], axis_z);
/*apply the rotations to a unit quaternion in yxz order*/
glm_quat_mul(rot_y, expected, expected);
glm_quat_mul(rot_x, expected, expected);
glm_quat_mul(rot_z, expected, expected);
/*use my function to get the quaternion*/
glm_euler_yxz_quat(result, angles);
/*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))
}
/*Start gimbal lock tests*/
for (float x = -90.0f; x <= 90.0f; x += 90.0f) {
for (float y = -90.0f; y <= 90.0f; y += 90.0f) {
for (float z = -90.0f; z <= 90.0f; z += 90.0f) {
/* angles that will cause gimbal lock*/
vec3 angles = {x, y, z};
/*quaternion representations for rotations*/
versor rot_x = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_y = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_z = {0.0f, 0.0f, 0.0f, 1.0f};
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};
versor expected = {0.0f, 0.0f, 0.0f, 1.0f};
versor result;
/*create the rotation quaternions using the angles and axises*/
glm_quatv(rot_x, angles[0], axis_x);
glm_quatv(rot_y, angles[1], axis_y);
glm_quatv(rot_z, angles[2], axis_z);
/*apply the rotations to a unit quaternion in xyz order*/
glm_quat_mul(rot_y, expected, expected);
glm_quat_mul(rot_x, expected, expected);
glm_quat_mul(rot_z, expected, expected);
/*use my function to get the quaternion*/
glm_euler_yxz_quat(result, angles);
/*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))
}
}
}
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, euler_yzx_quat) {
for (int i = 0; i < 100; i++) {
/*random angles for testing*/
vec3 angles;
/*quaternion representations for rotations*/
versor rot_x = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_y = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_z = {0.0f, 0.0f, 0.0f, 1.0f};
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};
versor expected = {0.0f, 0.0f, 0.0f, 1.0f};
versor result;
test_rand_vec3(angles);
/*create the rotation quaternions using the angles and axises*/
glm_quatv(rot_x, angles[0], axis_x);
glm_quatv(rot_y, angles[1], axis_y);
glm_quatv(rot_z, angles[2], axis_z);
/*apply the rotations to a unit quaternion in yzx order*/
glm_quat_mul(rot_y, expected, expected);
glm_quat_mul(rot_z, expected, expected);
glm_quat_mul(rot_x, expected, expected);
/*use my function to get the quaternion*/
glm_euler_yzx_quat(result, angles);
/*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))
}
/*Start gimbal lock tests*/
for (float x = -90.0f; x <= 90.0f; x += 90.0f) {
for (float y = -90.0f; y <= 90.0f; y += 90.0f) {
for (float z = -90.0f; z <= 90.0f; z += 90.0f) {
/* angles that will cause gimbal lock*/
vec3 angles = {x, y, z};
/*quaternion representations for rotations*/
versor rot_x = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_y = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_z = {0.0f, 0.0f, 0.0f, 1.0f};
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};
versor expected = {0.0f, 0.0f, 0.0f, 1.0f};
versor result;
/*create the rotation quaternions using the angles and axises*/
glm_quatv(rot_x, angles[0], axis_x);
glm_quatv(rot_y, angles[1], axis_y);
glm_quatv(rot_z, angles[2], axis_z);
/*apply the rotations to a unit quaternion in yzx order*/
glm_quat_mul(rot_y, expected, expected);
glm_quat_mul(rot_z, expected, expected);
glm_quat_mul(rot_x, expected, expected);
/*use my function to get the quaternion*/
glm_euler_yzx_quat(result, angles);
/*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))
}
}
}
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, euler_zxy_quat) {
for (int i = 0; i < 100; i++) {
/*random angles for testing*/
vec3 angles;
/*quaternion representations for rotations*/
versor rot_x = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_y = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_z = {0.0f, 0.0f, 0.0f, 1.0f};
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};
versor expected = {0.0f, 0.0f, 0.0f, 1.0f};
versor result;
test_rand_vec3(angles);
/*create the rotation quaternions using the angles and axises*/
glm_quatv(rot_x, angles[0], axis_x);
glm_quatv(rot_y, angles[1], axis_y);
glm_quatv(rot_z, angles[2], axis_z);
/*apply the rotations to a unit quaternion in zxy order*/
glm_quat_mul(rot_z, expected, expected);
glm_quat_mul(rot_x, expected, expected);
glm_quat_mul(rot_y, expected, expected);
/*use my function to get the quaternion*/
glm_euler_zxy_quat(result, angles);
/*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))
}
/*Start gimbal lock tests*/
for (float x = -90.0f; x <= 90.0f; x += 90.0f) {
for (float y = -90.0f; y <= 90.0f; y += 90.0f) {
for (float z = -90.0f; z <= 90.0f; z += 90.0f) {
/* angles that will cause gimbal lock*/
vec3 angles = {x, y, z};
/*quaternion representations for rotations*/
versor rot_x = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_y = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_z = {0.0f, 0.0f, 0.0f, 1.0f};
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};
versor expected = {0.0f, 0.0f, 0.0f, 1.0f};
versor result;
/*create the rotation quaternions using the angles and axises*/
glm_quatv(rot_x, angles[0], axis_x);
glm_quatv(rot_y, angles[1], axis_y);
glm_quatv(rot_z, angles[2], axis_z);
/*apply the rotations to a unit quaternion in zxy order*/
glm_quat_mul(rot_z, expected, expected);
glm_quat_mul(rot_x, expected, expected);
glm_quat_mul(rot_y, expected, expected);
/*use my function to get the quaternion*/
glm_euler_zxy_quat(result, angles);
/*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))
}
}
}
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, euler_zyx_quat) {
for (int i = 0; i < 100; i++) {
/*random angles for testing*/
vec3 angles;
/*quaternion representations for rotations*/
versor rot_x = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_y = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_z = {0.0f, 0.0f, 0.0f, 1.0f};
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};
versor expected = {0.0f, 0.0f, 0.0f, 1.0f};
versor result;
test_rand_vec3(angles);
/*create the rotation quaternions using the angles and axises*/
glm_quatv(rot_x, angles[0], axis_x);
glm_quatv(rot_y, angles[1], axis_y);
glm_quatv(rot_z, angles[2], axis_z);
/*apply the rotations to a unit quaternion in zyx order*/
glm_quat_mul(rot_z, expected, expected);
glm_quat_mul(rot_y, expected, expected);
glm_quat_mul(rot_x, expected, expected);
/*use my function to get the quaternion*/
glm_euler_zyx_quat(result, angles);
/*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))
}
/*Start gimbal lock tests*/
for (float x = -90.0f; x <= 90.0f; x += 90.0f) {
for (float y = -90.0f; y <= 90.0f; y += 90.0f) {
for (float z = -90.0f; z <= 90.0f; z += 90.0f) {
/* angles that will cause gimbal lock*/
vec3 angles = {x, y, z};
/*quaternion representations for rotations*/
versor rot_x = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_y = {0.0f, 0.0f, 0.0f, 1.0f};
versor rot_z = {0.0f, 0.0f, 0.0f, 1.0f};
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};
versor expected = {0.0f, 0.0f, 0.0f, 1.0f};
versor result;
/*create the rotation quaternions using the angles and axises*/
glm_quatv(rot_x, angles[0], axis_x);
glm_quatv(rot_y, angles[1], axis_y);
glm_quatv(rot_z, angles[2], axis_z);
/*apply the rotations to a unit quaternion in zyx order*/
glm_quat_mul(rot_z, expected, expected);
glm_quat_mul(rot_y, expected, expected);
glm_quat_mul(rot_x, expected, expected);
/*use my function to get the quaternion*/
glm_euler_zyx_quat(result, angles);
/*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))
}
}
}
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quatv) {
versor q1 = {1.0f, 2.0f, 3.0f, 4.0f};
vec3 v1, v2;
float a1;
test_rand_vec3(v1);
GLM(quatv)(q1, glm_rad(60.0f), v1);
glm_quat_axis(q1, v2);
a1 = glm_quat_angle(q1);
ASSERT(test_eq(a1, glm_rad(60.0f)))
glm_vec3_normalize(v1);
ASSERTIFY(test_assert_vec3_eq(v1, v2))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat) {
versor q1 = {1.0f, 2.0f, 3.0f, 4.0f};
vec3 v1, v2;
float a1;
test_rand_vec3(v1);
GLM(quat)(q1, glm_rad(60.0f), v1[0], v1[1], v1[2]);
glm_quat_axis(q1, v2);
a1 = glm_quat_angle(q1);
ASSERT(test_eq(a1, glm_rad(60.0f)))
glm_vec3_normalize(v1);
ASSERTIFY(test_assert_vec3_eq(v1, v2))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_copy) {
versor v1 = {10.0f, 9.0f, 8.0f, 78.0f};
versor v2 = {1.0f, 2.0f, 3.0f, 4.0f};
GLM(quat_copy)(v1, v2);
ASSERTIFY(test_assert_vec4_eq(v1, v2))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_from_vecs) {
versor q1, q2, q3, q4, q5, q6, q7;
vec3 v1 = {1.f, 0.f, 0.f}, v2 = {1.f, 0.f, 0.f}; /* parallel */
vec3 v3 = {0.f, 1.f, 0.f}, v4 = {1.f, 0.f, 0.f}; /* perpendicular */
vec3 v5 = {0.f, 0.f, 1.f}, v6 = {0.f, 0.f, -1.f}; /* straight */
vec3 v7, v8; /* random */
vec3 v9 = {0.57735026f, 0.57735026f, 0.57735026f}, /* acute */
v10 = {0.70710678f, 0.70710678f, 0.f};
vec3 v11 = {0.87287156f, 0.21821789f, 0.43643578f}, /* obtuse */
v12 = {-0.87287156f, 0.21821789f, 0.43643578f};
vec3 v13 = GLM_VEC3_ZERO_INIT; /* zero */
GLM(quat_from_vecs)(v1, v2, q1);
ASSERTIFY(test_assert_quat_eq_identity(q1))
GLM(quat_from_vecs)(v3, v4, q2);
GLM(quat_rotatev)(q2, v3, v3);
ASSERT(test_eq(GLM(vec3_dot)(v3, v4), 1.f))
ASSERT(test_eq(q2[0], 0.f))
ASSERT(test_eq(q2[1], 0.f))
ASSERT(test_eq(q2[2], -0.707106781187f))
ASSERT(test_eq(q2[3], 0.707106781187f))
GLM(quat_from_vecs)(v5, v6, q3);
GLM(quat_rotatev)(q3, v5, v5);
ASSERT(test_eq(GLM(vec3_dot)(v5, v6), 1.f))
ASSERT(test_eq(q3[0], 0.f))
ASSERT(test_eq(q3[1], -1.f))
ASSERT(test_eq(q3[2], 0.f))
ASSERT(test_eq(q3[3], 0.f))
test_rand_vec3(v7);
test_rand_vec3(v8);
GLM(vec3_normalize(v7));
GLM(vec3_normalize(v8));
GLM(quat_from_vecs)(v7, v8, q4);
GLM(quat_rotatev)(q4, v7, v7);
ASSERT(test_eq(GLM(vec3_dot)(v7, v8), 1.f))
GLM(quat_from_vecs)(v9, v10, q5);
GLM(quat_rotatev)(q5, v9, v9);
ASSERT(test_eq(GLM(vec3_dot)(v9, v10), 1.f))
GLM(quat_from_vecs)(v11, v12, q6);
GLM(quat_rotatev)(q6, v11, v11);
ASSERT(test_eq(GLM(vec3_dot)(v11, v12), 1.f))
GLM(quat_from_vecs)(v13, v1, q7);
ASSERTIFY(test_assert_quat_eq_identity(q7))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_norm) {
versor a = {10.0f, 9.0f, 8.0f, 78.0f};
float n1, n2;
n1 = GLM(quat_norm)(a);
n2 = sqrtf(a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3]);
ASSERT(test_eq(n1, n2))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_normalize_to) {
versor v1 = {2.0f, -3.0f, 4.0f, 5.0f}, v2;
float s = 1.0f;
float norm;
GLM(quat_normalize_to)(v1, v2);
norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2] + v1[3] * v1[3]);
if (norm <= 0.0f) {
ASSERTIFY(test_assert_quat_eq_identity(v1))
TEST_SUCCESS
}
norm = s / norm;
ASSERT(test_eq(v1[0] * norm, v2[0]))
ASSERT(test_eq(v1[1] * norm, v2[1]))
ASSERT(test_eq(v1[2] * norm, v2[2]))
ASSERT(test_eq(v1[3] * norm, v2[3]))
glm_vec4_zero(v1);
GLM(quat_normalize_to)(v1, v2);
ASSERTIFY(test_assert_quat_eq_identity(v2))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_normalize) {
versor v1 = {2.0f, -3.0f, 4.0f, 5.0f}, v2 = {2.0f, -3.0f, 4.0f, 5.0f};
float s = 1.0f;
float norm;
GLM(quat_normalize)(v2);
norm = sqrtf(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2] + v1[3] * v1[3]);
if (norm <= 0.0f) {
ASSERTIFY(test_assert_quat_eq_identity(v1))
TEST_SUCCESS
}
norm = s / norm;
ASSERT(test_eq(v1[0] * norm, v2[0]))
ASSERT(test_eq(v1[1] * norm, v2[1]))
ASSERT(test_eq(v1[2] * norm, v2[2]))
ASSERT(test_eq(v1[3] * norm, v2[3]))
glm_vec4_zero(v1);
GLM(quat_normalize)(v1);
ASSERTIFY(test_assert_quat_eq_identity(v1))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_dot) {
versor a = {10.0f, 9.0f, 8.0f, 78.0f};
versor b = {1.0f, 2.0f, 3.0f, 4.0f};
float dot1, dot2;
dot1 = GLM(quat_dot)(a, b);
dot2 = a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
ASSERT(test_eq(dot1, dot2))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_conjugate) {
versor a = {10.0f, 9.0f, 8.0f, 78.0f};
versor b = {1.0f, 2.0f, 3.0f, 4.0f};
versor d, e;
GLM(quat_conjugate)(a, d);
GLM(quat_conjugate)(b, e);
ASSERT(test_eq(d[0], -a[0]))
ASSERT(test_eq(d[1], -a[1]))
ASSERT(test_eq(d[2], -a[2]))
ASSERT(test_eq(d[3], a[3]))
ASSERT(test_eq(e[0], -b[0]))
ASSERT(test_eq(e[1], -b[1]))
ASSERT(test_eq(e[2], -b[2]))
ASSERT(test_eq(e[3], b[3]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_inv) {
versor a = {10.0f, 9.0f, 8.0f, 78.0f};
versor b = {1.0f, 2.0f, 3.0f, 4.0f};
versor d, e;
float n1, n2;
n1 = 1.0f / glm_vec4_norm2(a);
n2 = 1.0f / glm_vec4_norm2(b);
GLM(quat_inv)(a, d);
GLM(quat_inv)(b, e);
ASSERT(test_eq(d[0], -a[0] * n1))
ASSERT(test_eq(d[1], -a[1] * n1))
ASSERT(test_eq(d[2], -a[2] * n1))
ASSERT(test_eq(d[3], a[3] * n1))
ASSERT(test_eq(e[0], -b[0] * n2))
ASSERT(test_eq(e[1], -b[1] * n2))
ASSERT(test_eq(e[2], -b[2] * n2))
ASSERT(test_eq(e[3], b[3] * n2))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_add) {
versor a = {-10.0f, 9.0f, -8.0f, 56.0f};
versor b = {12.0f, 19.0f, -18.0f, 1.0f};
versor c, d;
c[0] = a[0] + b[0];
c[1] = a[1] + b[1];
c[2] = a[2] + b[2];
c[3] = a[3] + b[3];
GLM(quat_add)(a, b, d);
ASSERTIFY(test_assert_quat_eq(c, d))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_sub) {
vec4 a = {-10.0f, 9.0f, -8.0f, 56.0f};
vec4 b = {12.0f, 19.0f, -18.0f, 1.0f};
vec4 c, d;
c[0] = a[0] - b[0];
c[1] = a[1] - b[1];
c[2] = a[2] - b[2];
c[3] = a[3] - b[3];
GLM(quat_sub)(a, b, d);
ASSERTIFY(test_assert_quat_eq(c, d))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_real) {
versor a = {10.0f, 9.0f, 8.0f, 78.0f};
versor b = {1.0f, 2.0f, 3.0f, 4.0f};
ASSERT(test_eq(GLM(quat_real)(a), 78.0f))
ASSERT(test_eq(GLM(quat_real)(b), 4.0f))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_imag) {
versor a = {10.0f, 9.0f, 8.0f, 78.0f};
versor b = {1.0f, 2.0f, 3.0f, 4.0f};
vec3 d, e;
GLM(quat_imag)(a, d);
GLM(quat_imag)(b, e);
ASSERT(test_eq(d[0], a[0]))
ASSERT(test_eq(d[1], a[1]))
ASSERT(test_eq(d[2], a[2]))
ASSERT(test_eq(e[0], b[0]))
ASSERT(test_eq(e[1], b[1]))
ASSERT(test_eq(e[2], b[2]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_imagn) {
versor a = {10.0f, 9.0f, 8.0f, 78.0f};
versor b = {1.0f, 2.0f, 3.0f, 4.0f};
vec3 d, e;
GLM(quat_imagn)(a, d);
GLM(quat_imagn)(b, e);
glm_vec3_normalize(a);
glm_vec3_normalize(b);
glm_vec3_normalize(d);
glm_vec3_normalize(e);
ASSERT(test_eq(d[0], a[0]))
ASSERT(test_eq(d[1], a[1]))
ASSERT(test_eq(d[2], a[2]))
ASSERT(test_eq(e[0], b[0]))
ASSERT(test_eq(e[1], b[1]))
ASSERT(test_eq(e[2], b[2]))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_imaglen) {
versor a = {10.0f, 9.0f, 8.0f, 78.0f};
versor b = {1.0f, 2.0f, 3.0f, 4.0f};
ASSERT(test_eq(GLM(quat_imaglen)(a), glm_vec3_norm(a)));
ASSERT(test_eq(GLM(quat_imaglen)(b), glm_vec3_norm(b)));
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_angle) {
versor q1 = {1.0f, 2.0f, 3.0f, 4.0f}, q2, q3;
vec3 v1;
float a1, a2, a3;
test_rand_vec3(v1);
GLM(quatv)(q1, glm_rad(60.140f), v1);
GLM(quatv)(q2, glm_rad(160.04f), v1);
GLM(quatv)(q3, glm_rad(20.350f), v1);
a1 = GLM(quat_angle)(q1);
a2 = GLM(quat_angle)(q2);
a3 = GLM(quat_angle)(q3);
ASSERT(test_eq(a1, glm_rad(60.140f)))
ASSERT(test_eq(a2, glm_rad(160.04f)))
ASSERT(test_eq(a3, glm_rad(20.350f)))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_axis) {
versor q1 = {1.0f, 2.0f, 3.0f, 4.0f}, q2, q3;
vec3 v1, v2;
test_rand_vec3(v1);
GLM(quatv)(q1, glm_rad(60.0f), v1);
glm_quat_axis(q1, v2);
glm_vec3_normalize(v1);
ASSERTIFY(test_assert_vec3_eq(v1, v2))
test_rand_vec3(v1);
GLM(quatv)(q2, glm_rad(60.0f), v1);
glm_quat_axis(q2, v2);
glm_vec3_normalize(v1);
ASSERTIFY(test_assert_vec3_eq(v1, v2))
test_rand_vec3(v1);
GLM(quatv)(q3, glm_rad(60.0f), v1);
glm_quat_axis(q3, v2);
glm_vec3_normalize(v1);
ASSERTIFY(test_assert_vec3_eq(v1, v2))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_mul) {
versor q1 = {2.0f, 3.0f, 4.0f, 5.0f};
versor q2 = {6.0f, 7.0f, 8.0f, 9.0f};
versor q3;
versor q4;
vec3 v1 = {1.5f, 2.5f, 3.5f};
GLM(quat_mul)(q1, q2, q3);
ASSERT(test_eq(q3[0], q1[3] * q2[0] + q1[0] * q2[3] + q1[1] * q2[2] - q1[2] * q2[1]))
ASSERT(test_eq(q3[1], q1[3] * q2[1] - q1[0] * q2[2] + q1[1] * q2[3] + q1[2] * q2[0]))
ASSERT(test_eq(q3[2], q1[3] * q2[2] + q1[0] * q2[1] - q1[1] * q2[0] + q1[2] * q2[3]))
ASSERT(test_eq(q3[3], q1[3] * q2[3] - q1[0] * q2[0] - q1[1] * q2[1] - q1[2] * q2[2]))
glm_quatv(q1, glm_rad(30.0f), v1);
glm_quatv(q2, glm_rad(20.0f), v1);
glm_quatv(q3, glm_rad(50.0f), v1);
GLM(quat_mul)(q1, q2, q4);
ASSERTIFY(test_assert_quat_eq(q3, q4))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_mat4) {
mat4 m1, m2;
versor q1, q2, q3;
vec3 axis1;
vec3 axis2 = {1.9f, 2.3f, 4.5f};
int i;
GLM(quat)(q1, GLM_PI_4f, 1.9f, 2.3f, 4.5f);
GLM(quat_mat4)(q1, m1);
GLM(mat4_quat)(m1, q2);
GLM(rotate_make)(m2, GLM_PI_4f, axis2);
GLM(mat4_quat)(m1, q3);
GLM(quat_axis)(q3, axis1);
GLM(vec3_normalize)(axis1);
GLM(vec3_normalize)(axis2);
ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4f))
ASSERTIFY(test_assert_vec3_eq(axis1, axis2))
ASSERTIFY(test_assert_vec4_eq(q1, q2))
ASSERTIFY(test_assert_mat4_eq(m1, m2))
ASSERTIFY(test_assert_vec4_eq(q1, q3))
/* 1. test quat to mat and mat to quat */
for (i = 0; i < 1000; i++) {
test_rand_quat(q1);
GLM(quat_mat4)(q1, m1);
GLM(mat4_quat)(m1, q2);
GLM(quat_mat4)(q2, m2);
/* 2. test first quat and generated one equality */
ASSERTIFY(test_assert_quat_eq_abs(q1, q2));
/* 3. test first rot and second rotation */
/* almost equal */
ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.000009f));
}
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_mat4t) {
mat4 m1, m2;
versor q1, q2, q3;
vec3 axis1;
vec3 axis2 = {1.9f, 2.3f, 4.5f};
int i;
GLM(quat)(q1, GLM_PI_4f, 1.9f, 2.3f, 4.5f);
GLM(quat_mat4t)(q1, m1);
glm_mat4_transpose(m1);
GLM(mat4_quat)(m1, q2);
GLM(rotate_make)(m2, GLM_PI_4f, axis2);
GLM(mat4_quat)(m1, q3);
GLM(quat_axis)(q3, axis1);
GLM(vec3_normalize)(axis1);
GLM(vec3_normalize)(axis2);
ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4f))
ASSERTIFY(test_assert_vec3_eq(axis1, axis2))
ASSERTIFY(test_assert_vec4_eq(q1, q2))
ASSERTIFY(test_assert_mat4_eq(m1, m2))
ASSERTIFY(test_assert_vec4_eq(q1, q3))
/* 1. test quat to mat and mat to quat */
for (i = 0; i < 1000; i++) {
test_rand_quat(q1);
GLM(quat_mat4t)(q1, m1);
glm_mat4_transpose(m1);
GLM(mat4_quat)(m1, q2);
GLM(quat_mat4t)(q2, m2);
glm_mat4_transpose(m2);
/* 2. test first quat and generated one equality */
ASSERTIFY(test_assert_quat_eq_abs(q1, q2));
/* 3. test first rot and second rotation */
/* almost equal */
ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.000009f));
}
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_mat3) {
mat4 m1, m2;
mat3 m3;
versor q1, q2, q3;
vec3 axis1;
vec3 axis2 = {1.9f, 2.3f, 4.5f};
int i;
GLM(quat)(q1, GLM_PI_4f, 1.9f, 2.3f, 4.5f);
GLM(quat_mat3)(q1, m3);
glm_mat4_identity(m1);
glm_mat4_ins3(m3, m1);
GLM(mat4_quat)(m1, q2);
GLM(rotate_make)(m2, GLM_PI_4f, axis2);
GLM(mat4_quat)(m1, q3);
GLM(quat_axis)(q3, axis1);
GLM(vec3_normalize)(axis1);
GLM(vec3_normalize)(axis2);
ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4f))
ASSERTIFY(test_assert_vec3_eq(axis1, axis2))
ASSERTIFY(test_assert_vec4_eq(q1, q2))
ASSERTIFY(test_assert_mat4_eq(m1, m2))
ASSERTIFY(test_assert_vec4_eq(q1, q3))
/* 1. test quat to mat and mat to quat */
for (i = 0; i < 1000; i++) {
test_rand_quat(q1);
GLM(quat_mat3)(q1, m3);
glm_mat4_identity(m1);
glm_mat4_ins3(m3, m1);
GLM(mat4_quat)(m1, q2);
GLM(quat_mat3)(q2, m3);
glm_mat4_identity(m2);
glm_mat4_ins3(m3, m2);
/* 2. test first quat and generated one equality */
ASSERTIFY(test_assert_quat_eq_abs(q1, q2));
/* 3. test first rot and second rotation */
/* almost equal */
ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.000009f));
}
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_mat3t) {
mat4 m1, m2;
mat3 m3;
versor q1, q2, q3;
vec3 axis1;
vec3 axis2 = {1.9f, 2.3f, 4.5f};
int i;
GLM(quat)(q1, GLM_PI_4f, 1.9f, 2.3f, 4.5f);
GLM(quat_mat3t)(q1, m3);
glm_mat3_transpose(m3);
glm_mat4_identity(m1);
glm_mat4_ins3(m3, m1);
GLM(mat4_quat)(m1, q2);
GLM(rotate_make)(m2, GLM_PI_4f, axis2);
GLM(mat4_quat)(m1, q3);
GLM(quat_axis)(q3, axis1);
GLM(vec3_normalize)(axis1);
GLM(vec3_normalize)(axis2);
ASSERT(test_eq(glm_quat_angle(q3), GLM_PI_4f))
ASSERTIFY(test_assert_vec3_eq(axis1, axis2))
ASSERTIFY(test_assert_vec4_eq(q1, q2))
ASSERTIFY(test_assert_mat4_eq(m1, m2))
ASSERTIFY(test_assert_vec4_eq(q1, q3))
/* 1. test quat to mat and mat to quat */
for (i = 0; i < 1000; i++) {
test_rand_quat(q1);
GLM(quat_mat3t)(q1, m3);
glm_mat3_transpose(m3);
glm_mat4_identity(m1);
glm_mat4_ins3(m3, m1);
GLM(mat4_quat)(m1, q2);
GLM(quat_mat3t)(q2, m3);
glm_mat3_transpose(m3);
glm_mat4_identity(m2);
glm_mat4_ins3(m3, m2);
/* 2. test first quat and generated one equality */
ASSERTIFY(test_assert_quat_eq_abs(q1, q2));
/* 3. test first rot and second rotation */
/* almost equal */
ASSERTIFY(test_assert_mat4_eq2(m1, m2, 0.000009f));
}
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_lerp) {
versor v1 = {-100.0f, -200.0f, -10.0f, -10.0f};
versor v2 = {100.0f, 200.0f, 10.0f, 10.0f};
versor v3;
GLM(quat_lerp)(v1, v2, 0.5f, v3);
ASSERT(test_eq(v3[0], 0.0f))
ASSERT(test_eq(v3[1], 0.0f))
ASSERT(test_eq(v3[2], 0.0f))
ASSERT(test_eq(v3[3], 0.0f))
GLM(quat_lerp)(v1, v2, 0.75f, v3);
ASSERT(test_eq(v3[0], 50.0f))
ASSERT(test_eq(v3[1], 100.0f))
ASSERT(test_eq(v3[2], 5.0f))
ASSERT(test_eq(v3[3], 5.0f))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_lerpc) {
versor v1 = {-100.0f, -200.0f, -10.0f, -10.0f};
versor v2 = {100.0f, 200.0f, 10.0f, 10.0f};
versor v3;
GLM(quat_lerpc)(v1, v2, 0.5f, v3);
ASSERT(test_eq(v3[0], 0.0f))
ASSERT(test_eq(v3[1], 0.0f))
ASSERT(test_eq(v3[2], 0.0f))
ASSERT(test_eq(v3[3], 0.0f))
GLM(quat_lerpc)(v1, v2, 0.75f, v3);
ASSERT(test_eq(v3[0], 50.0f))
ASSERT(test_eq(v3[1], 100.0f))
ASSERT(test_eq(v3[2], 5.0f))
ASSERT(test_eq(v3[3], 5.0f))
GLM(quat_lerpc)(v1, v2, -1.75f, v3);
ASSERT(test_eq(v3[0], -100.0f))
ASSERT(test_eq(v3[1], -200.0f))
ASSERT(test_eq(v3[2], -10.0f))
ASSERT(test_eq(v3[3], -10.0f))
GLM(quat_lerpc)(v1, v2, 1.75f, v3);
ASSERT(test_eq(v3[0], 100.0f))
ASSERT(test_eq(v3[1], 200.0f))
ASSERT(test_eq(v3[2], 10.0f))
ASSERT(test_eq(v3[3], 10.0f))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_nlerp) {
versor q1, q2, q3, q4;
vec3 v1 = {10.0f, 0.0f, 0.0f}, v2;
glm_quatv(q1, glm_rad(30.0f), v1);
glm_quatv(q2, glm_rad(90.0f), v1);
GLM(quat_nlerp)(q1, q2, 1.0f, q3);
glm_quat_normalize(q2);
ASSERTIFY(test_assert_quat_eq(q2, q3));
glm_quatv(q1, glm_rad(30.001f), v1);
glm_quatv(q2, glm_rad(30.002f), v1);
GLM(quat_nlerp)(q1, q2, 0.7f, q3);
glm_quat_lerp(q1, q2, 0.7f, q4);
ASSERTIFY(test_assert_quat_eq(q3, q4));
glm_quatv(q1, glm_rad(30.0f), v1);
glm_quatv(q2, glm_rad(90.0f), v1);
GLM(quat_nlerp)(q1, q2, 0.5f, q3);
glm_quat_axis(q3, v2);
glm_vec3_normalize(v1);
glm_vec3_normalize(v2);
ASSERT(glm_quat_angle(q3) > glm_rad(30.0f));
ASSERT(glm_quat_angle(q3) < glm_rad(90.0f));
ASSERTIFY(test_assert_vec3_eq(v1, v2))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_slerp) {
versor q1, q2, q3, q4;
vec3 v1 = {10.0f, 0.0f, 0.0f}, v2;
glm_quatv(q1, glm_rad(30.0f), v1);
glm_quatv(q2, glm_rad(90.0f), v1);
q1[0] = 10.0f;
GLM(quat_slerp)(q1, q2, 1.0f, q3);
ASSERTIFY(test_assert_quat_eq(q1, q3));
glm_quatv(q1, glm_rad(30.001f), v1);
glm_quatv(q2, glm_rad(30.002f), v1);
GLM(quat_slerp)(q1, q2, 0.7f, q3);
glm_quat_lerp(q1, q2, 0.7f, q4);
ASSERTIFY(test_assert_quat_eq(q3, q4));
glm_quatv(q1, glm_rad(30.0f), v1);
glm_quatv(q2, glm_rad(90.0f), v1);
GLM(quat_slerp)(q1, q2, 0.5f, q3);
glm_quat_axis(q3, v2);
glm_vec3_normalize(v1);
glm_vec3_normalize(v2);
ASSERT(glm_quat_angle(q3) > glm_rad(30.0f));
ASSERT(glm_quat_angle(q3) < glm_rad(90.0f));
ASSERTIFY(test_assert_vec3_eq(v1, v2))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_look) {
versor q1;
vec3 v1 = {0.0f, 1.0f, 0.0f};
mat4 m1, m2;
glm_quat(q1, glm_rad(90.0f), 0.0f, 1.0f, 0.0f);
GLM(quat_look)(v1, q1, m1);
glm_look(v1, (vec3){-1.0f, 0.0f, 0.0f}, GLM_YUP, m2);
ASSERTIFY(test_assert_mat4_eq(m1, m2));
glm_quat(q1, glm_rad(180.0f), 1.0f, 0.0f, 0.0f);
GLM(quat_look)(v1, q1, m1);
glm_look(v1, (vec3){0.0f, 0.0f, 1.0f}, (vec3){0.0f, -1.0f, 0.0f}, m2);
ASSERTIFY(test_assert_mat4_eq(m1, m2));
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_for) {
versor q1, q2;
glm_quat(q1, glm_rad(90.0f), 0.0f, 1.0f, 0.0f);
GLM(quat_for)((vec3){-1.0f, 0.0f, 0.0f}, (vec3){0.0f, 1.0f, 0.0f}, q2);
ASSERTIFY(test_assert_quat_eq(q1, q2));
glm_quat(q2, glm_rad(90.0f), 1.0f, 0.0f, 0.0f);
GLM(quat_for)((vec3){0.0f, 1.0f, 0.0f}, (vec3){0.0f, 0.0f, 1.0f}, q1);
ASSERTIFY(test_assert_quat_eq(q1, q2));
glm_quat(q2, glm_rad(180.0f), 1.0f, 0.0f, 0.0f);
GLM(quat_for)((vec3){0.0f, 0.0f, 1.0f}, (vec3){0.0f, -1.0f, 0.0f}, q1);
ASSERTIFY(test_assert_quat_eq(q1, q2));
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_forp) {
versor q1, q2;
glm_quat(q1, glm_rad(90.0f), 0.0f, 1.0f, 0.0f);
GLM(quat_forp)((vec3){2.0f, 0.0f, 0.0f},
(vec3){1.0f, 0.0f, 0.0f},
(vec3){0.0f, 1.0f, 0.0f},
q2);
ASSERTIFY(test_assert_quat_eq(q1, q2));
glm_quat(q2, glm_rad(90.0f), 1.0f, 0.0f, 0.0f);
GLM(quat_forp)((vec3){0.0f, 1.0f, 0.0f},
(vec3){0.0f, 2.0f, 0.0f},
(vec3){0.0f, 0.0f, 1.0f},
q1);
ASSERTIFY(test_assert_quat_eq(q1, q2));
glm_quat(q2, glm_rad(180.0f), 1.0f, 0.0f, 0.0f);
GLM(quat_forp)((vec3){0.0f, 1.0f, 1.0f},
(vec3){0.0f, 1.0f, 2.0f},
(vec3){0.0f, -1.0f, 0.0f},
q1);
ASSERTIFY(test_assert_quat_eq(q1, q2));
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_rotatev) {
vec3 v1 = {1.0f, 0.0f, 0.0f}, v2 = {1.0f, 1.0f, 1.0f};
versor q;
/* rotate X around Y = -Z */
glm_quatv(q, GLM_PI_2f, GLM_YUP);
GLM(quat_rotatev)(q, v1, v1);
ASSERT(test_eq(v1[0], 0.0f))
ASSERT(test_eq(v1[1], 0.0f))
ASSERT(test_eq(v1[2], -1.0f))
/* rotate -Z around X = Y */
glm_quatv(q, GLM_PI_2f, GLM_XUP);
GLM(quat_rotatev)(q, v1, v1);
ASSERT(test_eq(v1[0], 0.0f))
ASSERT(test_eq(v1[1], 1.0f))
ASSERT(test_eq(v1[2], 0.0f))
/* rotate Y around Z = -X */
glm_quatv(q, GLM_PI_2f, GLM_ZUP);
GLM(quat_rotatev)(q, v1, v1);
ASSERT(test_eq(v1[0], -1.0f))
ASSERT(test_eq(v1[1], 0.0f))
ASSERT(test_eq(v1[2], 0.0f))
/* rotate v2 around Y by 90deg */
glm_quatv(q, GLM_PI_2f, GLM_YUP);
GLM(quat_rotatev)(q, v2, v2);
ASSERT(test_eq(v2[0], 1.0f))
ASSERT(test_eq(v2[1], 1.0f))
ASSERT(test_eq(v2[2], -1.0f))
/* rotate v2 around Y by 90deg */
glm_quatv(q, GLM_PI_2f, GLM_YUP);
GLM(quat_rotatev)(q, v2, v2);
ASSERT(test_eq(v2[0], -1.0f))
ASSERT(test_eq(v2[1], 1.0f))
ASSERT(test_eq(v2[2], -1.0f))
/* rotate v2 around Y by 90deg */
glm_quatv(q, GLM_PI_2f, GLM_YUP);
GLM(quat_rotatev)(q, v2, v2);
ASSERT(test_eq(v2[0], -1.0f))
ASSERT(test_eq(v2[1], 1.0f))
ASSERT(test_eq(v2[2], 1.0f))
/* rotate v2 around X by 90deg */
glm_quatv(q, GLM_PI_2f, GLM_XUP);
GLM(quat_rotatev)(q, v2, v2);
ASSERT(test_eq(v2[0], -1.0f))
ASSERT(test_eq(v2[1], -1.0f))
ASSERT(test_eq(v2[2], 1.0f))
/* rotate v2 around Z by 90deg */
glm_quatv(q, GLM_PI_2f, GLM_ZUP);
GLM(quat_rotatev)(q, v2, v2);
ASSERT(test_eq(v2[0], 1.0f))
ASSERT(test_eq(v2[1], -1.0f))
ASSERT(test_eq(v2[2], 1.0f))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_rotate) {
mat4 m1 = GLM_MAT4_IDENTITY_INIT, m2;
versor q1;
vec4 v1 = {1.0f, 0.0f, 0.0f, 1.0f};
/* rotate X around Y = -Z */
glm_quatv(q1, GLM_PI_2f, GLM_YUP);
GLM(quat_rotate)(m1, q1, m1);
glm_rotate_make(m2, GLM_PI_2f, GLM_YUP);
ASSERTIFY(test_assert_mat4_eq(m1, m2))
glm_mat4_mulv(m1, v1, v1);
ASSERT(test_eq(v1[0], 0.0f))
ASSERT(test_eq(v1[1], 0.0f))
ASSERT(test_eq(v1[2], -1.0f))
glm_mat4_identity(m1);
glm_mat4_identity(m2);
/* rotate -Z around X = Y */
glm_quatv(q1, GLM_PI_2f, GLM_XUP);
GLM(quat_rotate)(m1, q1, m1);
glm_rotate(m2, GLM_PI_2f, GLM_XUP);
ASSERTIFY(test_assert_mat4_eq(m1, m2))
glm_mat4_mulv(m1, v1, v1);
ASSERT(test_eq(v1[0], 0.0f))
ASSERT(test_eq(v1[1], 1.0f))
ASSERT(test_eq(v1[2], 0.0f))
glm_mat4_identity(m1);
glm_mat4_identity(m2);
/* rotate Y around X = +Z */
glm_quatv(q1, GLM_PI_2f, GLM_XUP);
GLM(quat_rotate)(m1, q1, m1);
glm_rotate(m2, GLM_PI_2f, GLM_XUP);
ASSERTIFY(test_assert_mat4_eq(m1, m2))
glm_mat4_mulv(m1, v1, v1);
ASSERT(test_eq(v1[0], 0.0f))
ASSERT(test_eq(v1[1], 0.0f))
ASSERT(test_eq(v1[2], 1.0f))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_rotate_at) {
mat4 m1 = GLM_MAT4_IDENTITY_INIT;
versor q1;
vec4 v1 = {1.0f, 0.0f, 0.0f, 1.0f};
glm_quatv(q1, GLM_PI_2f, GLM_YUP);
GLM(quat_rotate_at)(m1, q1, (vec3){0.5f, 0.0f, 0.0f});
glm_mat4_mulv(m1, v1, v1);
ASSERT(test_eq(v1[0], 0.5f))
ASSERT(test_eq(v1[1], 0.0f))
ASSERT(test_eq(v1[2], -0.5f))
glm_mat4_identity(m1);
glm_quatv(q1, GLM_PI_2f, GLM_ZUP);
GLM(quat_rotate_at)(m1, q1, (vec3){0.0f, 0.0f, 0.0f});
glm_mat4_mulv(m1, v1, v1);
ASSERT(test_eq(v1[0], 0.0f))
ASSERT(test_eq(v1[1], 0.5f))
ASSERT(test_eq(v1[2], -0.5f))
glm_mat4_identity(m1);
v1[0] = 1.0f;
v1[1] = 1.0f;
v1[2] = 1.0f;
glm_quatv(q1, GLM_PI_2f, GLM_XUP);
GLM(quat_rotate_at)(m1, q1, GLM_VEC3_ZERO);
glm_mat4_mulv(m1, v1, v1);
ASSERT(test_eq(v1[0], 1.0f))
ASSERT(test_eq(v1[1], -1.0f))
ASSERT(test_eq(v1[2], 1.0f))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_rotate_atm) {
mat4 m1 = GLM_MAT4_IDENTITY_INIT;
versor q1;
vec4 v1 = {1.0f, 0.0f, 0.0f, 1.0f};
glm_quatv(q1, GLM_PI_2f, GLM_YUP);
GLM(quat_rotate_atm)(m1, q1, (vec3){0.5f, 0.0f, 0.0f});
glm_mat4_mulv(m1, v1, v1);
ASSERT(test_eq(v1[0], 0.5f))
ASSERT(test_eq(v1[1], 0.0f))
ASSERT(test_eq(v1[2], -0.5f))
glm_quatv(q1, GLM_PI_2f, GLM_ZUP);
GLM(quat_rotate_atm)(m1, q1, (vec3){0.0f, 0.0f, 0.0f});
glm_mat4_mulv(m1, v1, v1);
ASSERT(test_eq(v1[0], 0.0f))
ASSERT(test_eq(v1[1], 0.5f))
ASSERT(test_eq(v1[2], -0.5f))
v1[0] = 1.0f;
v1[1] = 1.0f;
v1[2] = 1.0f;
glm_quatv(q1, GLM_PI_2f, GLM_XUP);
GLM(quat_rotate_atm)(m1, q1, GLM_VEC3_ZERO);
glm_mat4_mulv(m1, v1, v1);
ASSERT(test_eq(v1[0], 1.0f))
ASSERT(test_eq(v1[1], -1.0f))
ASSERT(test_eq(v1[2], 1.0f))
TEST_SUCCESS
}
TEST_IMPL(GLM_PREFIX, quat_make) {
versor dest[3];
float src[12] = {
7.2f, 1.0f, 2.5f, 6.1f,
0.2f, 2.8f, 17.3f, 5.1f,
4.2f, 7.3f, 6.6f, 8.8f
};
float *srcp = src;
unsigned int i, j;
for (i = 0, j = 0; i < sizeof(src) / sizeof(float); i+=4,j++) {
GLM(quat_make)(srcp + i, dest[j]);
ASSERT(test_eq(src[ i ], dest[j][0]));
ASSERT(test_eq(src[i+1], dest[j][1]));
ASSERT(test_eq(src[i+2], dest[j][2]));
ASSERT(test_eq(src[i+3], dest[j][3]));
}
TEST_SUCCESS
}