mirror of
https://github.com/recp/cglm.git
synced 2025-10-03 08:41:55 +00:00
1596 lines
41 KiB
C
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
|
|
}
|