mirror of
https://github.com/HandmadeMath/HandmadeMath.git
synced 2025-12-30 08:24:33 +00:00
c24e4ff873
These changes were all made by @dev-dwarf. Many thanks for his work on this! * Renaming * First Pass on 2.0UpdateTool * Another pass on UpdateTool, changed name * Another pass on UpdateTool, changed name * Do Renaming * Working on Angles Consistency * Passing Coverage * Remove unused arc-tangent functions * Change macro defaults By default if user is overriding trig functions assume their input and internal units are the same. * wrap in AngleDeg instead of AngleRad * Remove HMM_PREFIX configuration * Fix for Slerp https://discord.com/channels/239737791225790464/489148972305350656/1055167647274246265 Justified by most implementations of Slerp. EX: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/ * Handedness Changes * More renaming. C11 _Generics Generics enable by default when available (see lines 97-104). User can also force them by defining HANDMADE_MATH_C11_GENERICS Also fixed some missed things w.r.t renaming. My old tool didn't catch cases like HMM_MultiplyVec3f needing to be HMM_MulV3F instead of HMM_MulV3f. * Reuse more SSE codepaths for Quaternions Also improved quaternion tests. More work could be done here, see discussion here about optimizing slerp: https://discord.com/channels/239737791225790464/489148972305350656/1055167647274246265 * Just saving these alternate versions of SLerp * Reduce V4/M4 Linear Comb. codepaths * Simple implementation of 2x2 and 3x3 basic matrix operations. Also renamed Transpose to TransposeM4, so that we can have TransposeM2,M3 * Norm is dead! Long live Norm! As can be seen from the tests, precision has declined quite a bit from using the FastNorm implementations for various things. We can only guarantee about 0.001f precision for anything where a norm happens now. If this is undesired we can change back easily. * Started work on Matrix Inverses TODO: Tests for simple 4x4 Inverses * Matrix Inverses + Tests * Generics for Matrices and Rename MXd/f functions * Fixes + Better Output for UpdateTool * I think I count as a contributor : ) * Ported UpdateTool, Inlined my library code. * Moved tool to different repo https://github.com/dev-dwarf/HMM2.0UpdateTool * Remove small test change * Found some more references to atan functions * Standardize angle function names, use short names * Remove other slerp comments * woops that wasnt meant to be commited. * Finish changing ToRadians to ToRad * Fix [] overloads per https://discord.com/channels/239737791225790464/600063880533770251/1051600188302692402 * Tests for 2x2, 3x3 Matrices and Other Matrix Ops * Add an option to use Z: [0, 1] range for projection matrices. This will make HMM more convenient to use with other graphics APIs such as Direct3d and Metal. * Update test imports * #if should've been #ifdef! * Implement requested changes
277 lines
8.8 KiB
C
277 lines
8.8 KiB
C
#include "../HandmadeTest.h"
|
|
|
|
TEST(QuaternionOps, Inverse)
|
|
{
|
|
HMM_Quat q1 = HMM_Q(1.0f, 2.0f, 3.0f, 4.0f);
|
|
HMM_Quat inverse = HMM_InvQ(q1);
|
|
|
|
HMM_Quat result = HMM_MulQ(q1, inverse);
|
|
|
|
EXPECT_FLOAT_EQ(result.X, 0.0f);
|
|
EXPECT_FLOAT_EQ(result.Y, 0.0f);
|
|
EXPECT_FLOAT_EQ(result.Z, 0.0f);
|
|
EXPECT_FLOAT_EQ(result.W, 1.0f);
|
|
}
|
|
|
|
TEST(QuaternionOps, Dot)
|
|
{
|
|
HMM_Quat q1 = HMM_Q(1.0f, 2.0f, 3.0f, 4.0f);
|
|
HMM_Quat q2 = HMM_Q(5.0f, 6.0f, 7.0f, 8.0f);
|
|
|
|
{
|
|
float result = HMM_DotQ(q1, q2);
|
|
EXPECT_FLOAT_EQ(result, 70.0f);
|
|
}
|
|
#ifdef __cplusplus
|
|
{
|
|
float result = HMM_Dot(q1, q2);
|
|
EXPECT_FLOAT_EQ(result, 70.0f);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
TEST(QuaternionOps, Normalize)
|
|
{
|
|
HMM_Quat q = HMM_Q(1.0f, 2.0f, 3.0f, 4.0f);
|
|
|
|
{
|
|
HMM_Quat result = HMM_NormQ(q);
|
|
EXPECT_NEAR(result.X, 0.1825741858f, 0.001f);
|
|
EXPECT_NEAR(result.Y, 0.3651483717f, 0.001f);
|
|
EXPECT_NEAR(result.Z, 0.5477225575f, 0.001f);
|
|
EXPECT_NEAR(result.W, 0.7302967433f, 0.001f);
|
|
}
|
|
#ifdef __cplusplus
|
|
{
|
|
HMM_Quat result = HMM_Norm(q);
|
|
EXPECT_NEAR(result.X, 0.1825741858f, 0.001f);
|
|
EXPECT_NEAR(result.Y, 0.3651483717f, 0.001f);
|
|
EXPECT_NEAR(result.Z, 0.5477225575f, 0.001f);
|
|
EXPECT_NEAR(result.W, 0.7302967433f, 0.001f);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
TEST(QuaternionOps, NLerp)
|
|
{
|
|
HMM_Quat from = HMM_Q(0.0f, 0.0f, 0.0f, 1.0f);
|
|
HMM_Quat to = HMM_Q(0.5f, 0.5f, -0.5f, 0.5f);
|
|
|
|
HMM_Quat result = HMM_NLerp(from, 0.5f, to);
|
|
EXPECT_NEAR(result.X, 0.28867513f, 0.001f);
|
|
EXPECT_NEAR(result.Y, 0.28867513f, 0.001f);
|
|
EXPECT_NEAR(result.Z, -0.28867513f, 0.001f);
|
|
EXPECT_NEAR(result.W, 0.86602540f, 0.001f);
|
|
}
|
|
|
|
TEST(QuaternionOps, SLerp)
|
|
{
|
|
HMM_Quat from = HMM_Q(0.0f, 0.0f, 0.0f, 1.0f);
|
|
HMM_Quat to = HMM_Q(0.5f, 0.5f, -0.5f, 0.5f);
|
|
|
|
{
|
|
HMM_Quat result = HMM_SLerp(from, 0.0f, to);
|
|
EXPECT_NEAR(result.X, 0.0f, 0.001f);
|
|
EXPECT_NEAR(result.Y, 0.0f, 0.001f);
|
|
EXPECT_NEAR(result.Z, 0.0f, 0.001f);
|
|
EXPECT_NEAR(result.W, 1.0, 0.001f);
|
|
}
|
|
{
|
|
HMM_Quat result = HMM_SLerp(from, 0.25f, to);
|
|
EXPECT_NEAR(result.X, 0.149429246f, 0.001f);
|
|
EXPECT_NEAR(result.Y, 0.149429246f, 0.001f);
|
|
EXPECT_NEAR(result.Z, -0.149429246f, 0.001f);
|
|
EXPECT_NEAR(result.W, 0.965925812f, 0.001f);
|
|
}
|
|
{
|
|
HMM_Quat result = HMM_SLerp(from, 0.5f, to);
|
|
EXPECT_NEAR(result.X, 0.28867513f, 0.001f);
|
|
EXPECT_NEAR(result.Y, 0.28867513f, 0.001f);
|
|
EXPECT_NEAR(result.Z, -0.28867513f, 0.001f);
|
|
EXPECT_NEAR(result.W, 0.86602540f, 0.001f);
|
|
}
|
|
{
|
|
HMM_Quat result = HMM_SLerp(from, 0.75f, to);
|
|
EXPECT_NEAR(result.X, 0.40824830f, 0.001f);
|
|
EXPECT_NEAR(result.Y, 0.40824830f, 0.001f);
|
|
EXPECT_NEAR(result.Z, -0.40824830f, 0.001f);
|
|
EXPECT_NEAR(result.W, 0.70710676f, 0.001f);
|
|
}
|
|
{
|
|
HMM_Quat result = HMM_SLerp(from, 1.0f, to);
|
|
EXPECT_NEAR(result.X, 0.5f, 0.001f);
|
|
EXPECT_NEAR(result.Y, 0.5f, 0.001f);
|
|
EXPECT_NEAR(result.Z, -0.5f, 0.001f);
|
|
EXPECT_NEAR(result.W, 0.5f, 0.001f);
|
|
}
|
|
}
|
|
|
|
TEST(QuaternionOps, QuatToMat4)
|
|
{
|
|
const float abs_error = 0.001f;
|
|
|
|
HMM_Quat rot = HMM_Q(0.707107f, 0.0f, 0.0f, 0.707107f);
|
|
|
|
HMM_Mat4 result = HMM_QToM4(rot);
|
|
|
|
EXPECT_NEAR(result.Elements[0][0], 1.0f, abs_error);
|
|
EXPECT_NEAR(result.Elements[0][1], 0.0f, abs_error);
|
|
EXPECT_NEAR(result.Elements[0][2], 0.0f, abs_error);
|
|
EXPECT_NEAR(result.Elements[0][3], 0.0f, abs_error);
|
|
|
|
EXPECT_NEAR(result.Elements[1][0], 0.0f, abs_error);
|
|
EXPECT_NEAR(result.Elements[1][1], 0.0f, abs_error);
|
|
EXPECT_NEAR(result.Elements[1][2], 1.0f, abs_error);
|
|
EXPECT_NEAR(result.Elements[1][3], 0.0f, abs_error);
|
|
|
|
EXPECT_NEAR(result.Elements[2][0], 0.0f, abs_error);
|
|
EXPECT_NEAR(result.Elements[2][1], -1.0f, abs_error);
|
|
EXPECT_NEAR(result.Elements[2][2], 0.0f, abs_error);
|
|
EXPECT_NEAR(result.Elements[2][3], 0.0f, abs_error);
|
|
|
|
EXPECT_NEAR(result.Elements[3][0], 0.0f, abs_error);
|
|
EXPECT_NEAR(result.Elements[3][1], 0.0f, abs_error);
|
|
EXPECT_NEAR(result.Elements[3][2], 0.0f, abs_error);
|
|
EXPECT_NEAR(result.Elements[3][3], 1.0f, abs_error);
|
|
}
|
|
|
|
TEST(QuaternionOps, Mat4ToQuat)
|
|
{
|
|
const float abs_error = 0.0001f;
|
|
|
|
// Rotate 90 degrees on the X axis
|
|
{
|
|
HMM_Mat4 m = HMM_Rotate_RH(HMM_AngleDeg(90.0f), HMM_V3(1, 0, 0));
|
|
HMM_Quat result = HMM_M4ToQ_RH(m);
|
|
|
|
float cosf = 0.707107f; // cos(90/2 degrees)
|
|
float sinf = 0.707107f; // sin(90/2 degrees)
|
|
|
|
EXPECT_NEAR(result.X, sinf, abs_error);
|
|
EXPECT_NEAR(result.Y, 0.0f, abs_error);
|
|
EXPECT_NEAR(result.Z, 0.0f, abs_error);
|
|
EXPECT_NEAR(result.W, cosf, abs_error);
|
|
}
|
|
|
|
// Rotate 90 degrees on the Y axis (axis not normalized, just for fun)
|
|
{
|
|
HMM_Mat4 m = HMM_Rotate_RH(HMM_AngleDeg(90.0f), HMM_V3(0, 2, 0));
|
|
HMM_Quat result = HMM_M4ToQ_RH(m);
|
|
|
|
float cosf = 0.707107f; // cos(90/2 degrees)
|
|
float sinf = 0.707107f; // sin(90/2 degrees)
|
|
|
|
EXPECT_NEAR(result.X, 0.0f, abs_error);
|
|
EXPECT_NEAR(result.Y, sinf, abs_error);
|
|
EXPECT_NEAR(result.Z, 0.0f, abs_error);
|
|
EXPECT_NEAR(result.W, cosf, abs_error);
|
|
}
|
|
|
|
// Rotate 90 degrees on the Z axis
|
|
{
|
|
HMM_Mat4 m = HMM_Rotate_RH(HMM_AngleDeg(90.0f), HMM_V3(0, 0, 1));
|
|
HMM_Quat result = HMM_M4ToQ_RH(m);
|
|
|
|
float cosf = 0.707107f; // cos(90/2 degrees)
|
|
float sinf = 0.707107f; // sin(90/2 degrees)
|
|
|
|
EXPECT_NEAR(result.X, 0.0f, abs_error);
|
|
EXPECT_NEAR(result.Y, 0.0f, abs_error);
|
|
EXPECT_NEAR(result.Z, sinf, abs_error);
|
|
EXPECT_NEAR(result.W, cosf, abs_error);
|
|
}
|
|
|
|
// Rotate 45 degrees on the X axis (this hits case 4)
|
|
{
|
|
HMM_Mat4 m = HMM_Rotate_RH(HMM_AngleDeg(45.0f), HMM_V3(1, 0, 0));
|
|
HMM_Quat result = HMM_M4ToQ_RH(m);
|
|
|
|
float cosf = 0.9238795325f; // cos(90/2 degrees)
|
|
float sinf = 0.3826834324f; // sin(90/2 degrees)
|
|
|
|
EXPECT_NEAR(result.X, sinf, abs_error);
|
|
EXPECT_NEAR(result.Y, 0.0f, abs_error);
|
|
EXPECT_NEAR(result.Z, 0.0f, abs_error);
|
|
EXPECT_NEAR(result.W, cosf, abs_error);
|
|
}
|
|
|
|
/* NOTE(lcf): Left-handed cases. Since both Rotate and M4ToQ are LH results should be
|
|
the same with no changes to input. */
|
|
// Rotate 90 degrees on the X axis
|
|
{
|
|
HMM_Mat4 m = HMM_Rotate_LH(HMM_AngleDeg(90.0f), HMM_V3(1, 0, 0));
|
|
HMM_Quat result = HMM_M4ToQ_LH(m);
|
|
|
|
float cosf = 0.707107f; // cos(90/2 degrees)
|
|
float sinf = 0.707107f; // sin(90/2 degrees)
|
|
|
|
EXPECT_NEAR(result.X, sinf, abs_error);
|
|
EXPECT_NEAR(result.Y, 0.0f, abs_error);
|
|
EXPECT_NEAR(result.Z, 0.0f, abs_error);
|
|
EXPECT_NEAR(result.W, cosf, abs_error);
|
|
}
|
|
|
|
// Rotate 90 degrees on the Y axis (axis not normalized, just for fun)
|
|
{
|
|
HMM_Mat4 m = HMM_Rotate_LH(HMM_AngleDeg(90.0f), HMM_V3(0, 2, 0));
|
|
HMM_Quat result = HMM_M4ToQ_LH(m);
|
|
|
|
float cosf = 0.707107f; // cos(90/2 degrees)
|
|
float sinf = 0.707107f; // sin(90/2 degrees)
|
|
|
|
EXPECT_NEAR(result.X, 0.0f, abs_error);
|
|
EXPECT_NEAR(result.Y, sinf, abs_error);
|
|
EXPECT_NEAR(result.Z, 0.0f, abs_error);
|
|
EXPECT_NEAR(result.W, cosf, abs_error);
|
|
}
|
|
|
|
// Rotate 90 degrees on the Z axis
|
|
{
|
|
HMM_Mat4 m = HMM_Rotate_LH(HMM_AngleDeg(90.0f), HMM_V3(0, 0, 1));
|
|
HMM_Quat result = HMM_M4ToQ_LH(m);
|
|
|
|
float cosf = 0.707107f; // cos(90/2 degrees)
|
|
float sinf = 0.707107f; // sin(90/2 degrees)
|
|
|
|
EXPECT_NEAR(result.X, 0.0f, abs_error);
|
|
EXPECT_NEAR(result.Y, 0.0f, abs_error);
|
|
EXPECT_NEAR(result.Z, sinf, abs_error);
|
|
EXPECT_NEAR(result.W, cosf, abs_error);
|
|
}
|
|
|
|
// Rotate 45 degrees on the X axis (this hits case 4)
|
|
{
|
|
HMM_Mat4 m = HMM_Rotate_LH(HMM_AngleDeg(45.0f), HMM_V3(1, 0, 0));
|
|
HMM_Quat result = HMM_M4ToQ_LH(m);
|
|
|
|
float cosf = 0.9238795325f; // cos(90/2 degrees)
|
|
float sinf = 0.3826834324f; // sin(90/2 degrees)
|
|
|
|
EXPECT_NEAR(result.X, sinf, abs_error);
|
|
EXPECT_NEAR(result.Y, 0.0f, abs_error);
|
|
EXPECT_NEAR(result.Z, 0.0f, abs_error);
|
|
EXPECT_NEAR(result.W, cosf, abs_error);
|
|
}
|
|
}
|
|
|
|
TEST(QuaternionOps, FromAxisAngle)
|
|
{
|
|
HMM_Vec3 axis = HMM_V3(1.0f, 0.0f, 0.0f);
|
|
float angle = HMM_PI32 / 2.0f;
|
|
|
|
{
|
|
HMM_Quat result = HMM_QFromAxisAngle_RH(axis, angle);
|
|
EXPECT_NEAR(result.X, 0.707107f, 0.001f);
|
|
EXPECT_NEAR(result.Y, 0.0f, 0.001f);
|
|
EXPECT_NEAR(result.Z, 0.0f, 0.001f);
|
|
EXPECT_NEAR(result.W, 0.707107f, 0.001f);
|
|
}
|
|
{
|
|
HMM_Quat result = HMM_QFromAxisAngle_LH(axis, angle);
|
|
EXPECT_NEAR(result.X, -0.707107f, 0.001f);
|
|
EXPECT_NEAR(result.Y, 0.0f, 0.001f);
|
|
EXPECT_NEAR(result.Z, 0.0f, 0.001f);
|
|
EXPECT_NEAR(result.W, 0.707107f, 0.001f);
|
|
}
|
|
}
|