mirror of
https://github.com/HandmadeMath/HandmadeMath.git
synced 2025-09-07 18:58:19 +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
283 lines
7.3 KiB
C
283 lines
7.3 KiB
C
#include "../HandmadeTest.h"
|
|
|
|
TEST(VectorOps, LengthSquared)
|
|
{
|
|
HMM_Vec2 v2 = HMM_V2(1.0f, -2.0f);
|
|
HMM_Vec3 v3 = HMM_V3(1.0f, -2.0f, 3.0f);
|
|
HMM_Vec4 v4 = HMM_V4(1.0f, -2.0f, 3.0f, 1.0f);
|
|
|
|
EXPECT_FLOAT_EQ(HMM_LenSqrV2(v2), 5.0f);
|
|
EXPECT_FLOAT_EQ(HMM_LenSqrV3(v3), 14.0f);
|
|
EXPECT_FLOAT_EQ(HMM_LenSqrV4(v4), 15.0f);
|
|
|
|
#ifdef __cplusplus
|
|
EXPECT_FLOAT_EQ(HMM_LenSqr(v2), 5.0f);
|
|
EXPECT_FLOAT_EQ(HMM_LenSqr(v3), 14.0f);
|
|
EXPECT_FLOAT_EQ(HMM_LenSqr(v4), 15.0f);
|
|
#endif
|
|
}
|
|
|
|
TEST(VectorOps, Length)
|
|
{
|
|
HMM_Vec2 v2 = HMM_V2(1.0f, -9.0f);
|
|
HMM_Vec3 v3 = HMM_V3(2.0f, -3.0f, 6.0f);
|
|
HMM_Vec4 v4 = HMM_V4(2.0f, -3.0f, 6.0f, 12.0f);
|
|
|
|
EXPECT_FLOAT_EQ(HMM_LenV2(v2), 9.0553856f);
|
|
EXPECT_FLOAT_EQ(HMM_LenV3(v3), 7.0f);
|
|
EXPECT_FLOAT_EQ(HMM_LenV4(v4), 13.892444f);
|
|
|
|
#ifdef __cplusplus
|
|
EXPECT_FLOAT_EQ(HMM_Len(v2), 9.0553856f);
|
|
EXPECT_FLOAT_EQ(HMM_Len(v3), 7.0f);
|
|
EXPECT_FLOAT_EQ(HMM_Len(v4), 13.892444f);
|
|
#endif
|
|
}
|
|
|
|
TEST(VectorOps, Normalize)
|
|
{
|
|
HMM_Vec2 v2 = HMM_V2(1.0f, -2.0f);
|
|
HMM_Vec3 v3 = HMM_V3(1.0f, -2.0f, 3.0f);
|
|
HMM_Vec4 v4 = HMM_V4(1.0f, -2.0f, 3.0f, -1.0f);
|
|
|
|
{
|
|
HMM_Vec2 result = HMM_NormV2(v2);
|
|
EXPECT_NEAR(HMM_LenV2(result), 1.0f, 0.001f);
|
|
EXPECT_GT(result.X, 0.0f);
|
|
EXPECT_LT(result.Y, 0.0f);
|
|
}
|
|
{
|
|
HMM_Vec3 result = HMM_NormV3(v3);
|
|
EXPECT_NEAR(HMM_LenV3(result), 1.0f, 0.001f);
|
|
EXPECT_GT(result.X, 0.0f);
|
|
EXPECT_LT(result.Y, 0.0f);
|
|
EXPECT_GT(result.Z, 0.0f);
|
|
}
|
|
{
|
|
HMM_Vec4 result = HMM_NormV4(v4);
|
|
EXPECT_NEAR(HMM_LenV4(result), 1.0f, 0.001f);
|
|
EXPECT_GT(result.X, 0.0f);
|
|
EXPECT_LT(result.Y, 0.0f);
|
|
EXPECT_GT(result.Z, 0.0f);
|
|
EXPECT_LT(result.W, 0.0f);
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
{
|
|
HMM_Vec2 result = HMM_Norm(v2);
|
|
EXPECT_NEAR(HMM_LenV2(result), 1.0f, 0.001f);
|
|
EXPECT_GT(result.X, 0.0f);
|
|
EXPECT_LT(result.Y, 0.0f);
|
|
}
|
|
{
|
|
HMM_Vec3 result = HMM_Norm(v3);
|
|
EXPECT_NEAR(HMM_LenV3(result), 1.0f, 0.001f);
|
|
EXPECT_GT(result.X, 0.0f);
|
|
EXPECT_LT(result.Y, 0.0f);
|
|
EXPECT_GT(result.Z, 0.0f);
|
|
}
|
|
{
|
|
HMM_Vec4 result = HMM_Norm(v4);
|
|
EXPECT_NEAR(HMM_LenV4(result), 1.0f, 0.001f);
|
|
EXPECT_GT(result.X, 0.0f);
|
|
EXPECT_LT(result.Y, 0.0f);
|
|
EXPECT_GT(result.Z, 0.0f);
|
|
EXPECT_LT(result.W, 0.0f);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
TEST(VectorOps, NormalizeZero)
|
|
{
|
|
HMM_Vec2 v2 = HMM_V2(0.0f, 0.0f);
|
|
HMM_Vec3 v3 = HMM_V3(0.0f, 0.0f, 0.0f);
|
|
HMM_Vec4 v4 = HMM_V4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
|
|
{
|
|
HMM_Vec2 result = HMM_NormV2(v2);
|
|
EXPECT_FLOAT_EQ(result.X, 0.0f);
|
|
EXPECT_FLOAT_EQ(result.Y, 0.0f);
|
|
}
|
|
{
|
|
HMM_Vec3 result = HMM_NormV3(v3);
|
|
EXPECT_FLOAT_EQ(result.X, 0.0f);
|
|
EXPECT_FLOAT_EQ(result.Y, 0.0f);
|
|
EXPECT_FLOAT_EQ(result.Z, 0.0f);
|
|
}
|
|
{
|
|
HMM_Vec4 result = HMM_NormV4(v4);
|
|
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, 0.0f);
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
{
|
|
HMM_Vec2 result = HMM_Norm(v2);
|
|
EXPECT_FLOAT_EQ(result.X, 0.0f);
|
|
EXPECT_FLOAT_EQ(result.Y, 0.0f);
|
|
}
|
|
{
|
|
HMM_Vec3 result = HMM_Norm(v3);
|
|
EXPECT_FLOAT_EQ(result.X, 0.0f);
|
|
EXPECT_FLOAT_EQ(result.Y, 0.0f);
|
|
EXPECT_FLOAT_EQ(result.Z, 0.0f);
|
|
}
|
|
{
|
|
HMM_Vec4 result = HMM_Norm(v4);
|
|
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, 0.0f);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
TEST(VectorOps, Cross)
|
|
{
|
|
HMM_Vec3 v1 = HMM_V3(1.0f, 2.0f, 3.0f);
|
|
HMM_Vec3 v2 = HMM_V3(4.0f, 5.0f, 6.0f);
|
|
|
|
HMM_Vec3 result = HMM_Cross(v1, v2);
|
|
|
|
EXPECT_FLOAT_EQ(result.X, -3.0f);
|
|
EXPECT_FLOAT_EQ(result.Y, 6.0f);
|
|
EXPECT_FLOAT_EQ(result.Z, -3.0f);
|
|
}
|
|
|
|
TEST(VectorOps, DotVec2)
|
|
{
|
|
HMM_Vec2 v1 = HMM_V2(1.0f, 2.0f);
|
|
HMM_Vec2 v2 = HMM_V2(3.0f, 4.0f);
|
|
|
|
EXPECT_FLOAT_EQ(HMM_DotV2(v1, v2), 11.0f);
|
|
#ifdef __cplusplus
|
|
EXPECT_FLOAT_EQ(HMM_Dot(v1, v2), 11.0f);
|
|
#endif
|
|
}
|
|
|
|
TEST(VectorOps, DotVec3)
|
|
{
|
|
HMM_Vec3 v1 = HMM_V3(1.0f, 2.0f, 3.0f);
|
|
HMM_Vec3 v2 = HMM_V3(4.0f, 5.0f, 6.0f);
|
|
|
|
EXPECT_FLOAT_EQ(HMM_DotV3(v1, v2), 32.0f);
|
|
#ifdef __cplusplus
|
|
EXPECT_FLOAT_EQ(HMM_Dot(v1, v2), 32.0f);
|
|
#endif
|
|
}
|
|
|
|
TEST(VectorOps, DotVec4)
|
|
{
|
|
HMM_Vec4 v1 = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
|
|
HMM_Vec4 v2 = HMM_V4(5.0f, 6.0f, 7.0f, 8.0f);
|
|
|
|
EXPECT_FLOAT_EQ(HMM_DotV4(v1, v2), 70.0f);
|
|
#ifdef __cplusplus
|
|
EXPECT_FLOAT_EQ(HMM_Dot(v1, v2), 70.0f);
|
|
#endif
|
|
}
|
|
|
|
TEST(VectorOps, LerpV2)
|
|
{
|
|
HMM_Vec2 v1 = HMM_V2(1.0f, 0.0f);
|
|
HMM_Vec2 v2 = HMM_V2(0.0f, 1.0f);
|
|
|
|
{
|
|
HMM_Vec2 result = HMM_LerpV2(v1, 0.5, v2);
|
|
EXPECT_FLOAT_EQ(result.X, 0.5f);
|
|
EXPECT_FLOAT_EQ(result.Y, 0.5f);
|
|
}
|
|
#ifdef __cplusplus
|
|
{
|
|
HMM_Vec2 result = HMM_Lerp(v1, 0.5, v2);
|
|
EXPECT_FLOAT_EQ(result.X, 0.5f);
|
|
EXPECT_FLOAT_EQ(result.Y, 0.5f);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
TEST(VectorOps, LerpV3)
|
|
{
|
|
HMM_Vec3 v1 = HMM_V3(1.0f, 1.0f, 0.0f);
|
|
HMM_Vec3 v2 = HMM_V3(0.0f, 1.0f, 1.0f);
|
|
|
|
{
|
|
HMM_Vec3 result = HMM_LerpV3(v1, 0.5, v2);
|
|
EXPECT_FLOAT_EQ(result.X, 0.5f);
|
|
EXPECT_FLOAT_EQ(result.Y, 1.0f);
|
|
EXPECT_FLOAT_EQ(result.Z, 0.5f);
|
|
}
|
|
#ifdef __cplusplus
|
|
{
|
|
HMM_Vec3 result = HMM_Lerp(v1, 0.5, v2);
|
|
EXPECT_FLOAT_EQ(result.X, 0.5f);
|
|
EXPECT_FLOAT_EQ(result.Y, 1.0f);
|
|
EXPECT_FLOAT_EQ(result.Z, 0.5f);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
TEST(VectorOps, LerpV4)
|
|
{
|
|
HMM_Vec4 v1 = HMM_V4(1.0f, 1.0f, 0.0f, 1.0f);
|
|
HMM_Vec4 v2 = HMM_V4(0.0f, 1.0f, 1.0f, 1.0f);
|
|
|
|
{
|
|
HMM_Vec4 result = HMM_LerpV4(v1, 0.5, v2);
|
|
EXPECT_FLOAT_EQ(result.X, 0.5f);
|
|
EXPECT_FLOAT_EQ(result.Y, 1.0f);
|
|
EXPECT_FLOAT_EQ(result.Z, 0.5f);
|
|
EXPECT_FLOAT_EQ(result.W, 1.0f);
|
|
}
|
|
#ifdef __cplusplus
|
|
{
|
|
HMM_Vec4 result = HMM_Lerp(v1, 0.5, v2);
|
|
EXPECT_FLOAT_EQ(result.X, 0.5f);
|
|
EXPECT_FLOAT_EQ(result.Y, 1.0f);
|
|
EXPECT_FLOAT_EQ(result.Z, 0.5f);
|
|
EXPECT_FLOAT_EQ(result.W, 1.0f);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* MatrixOps tests
|
|
*/
|
|
|
|
TEST(MatrixOps, TransposeM4)
|
|
{
|
|
HMM_Mat4 m4 = HMM_M4(); // will have 1 - 16
|
|
|
|
// Fill the matrix
|
|
int Counter = 1;
|
|
for (int Column = 0; Column < 4; ++Column)
|
|
{
|
|
for (int Row = 0; Row < 4; ++Row)
|
|
{
|
|
m4.Elements[Column][Row] = Counter;
|
|
++Counter;
|
|
}
|
|
}
|
|
|
|
// Test the matrix
|
|
HMM_Mat4 result = HMM_TransposeM4(m4);
|
|
EXPECT_FLOAT_EQ(result.Elements[0][0], 1.0f);
|
|
EXPECT_FLOAT_EQ(result.Elements[0][1], 5.0f);
|
|
EXPECT_FLOAT_EQ(result.Elements[0][2], 9.0f);
|
|
EXPECT_FLOAT_EQ(result.Elements[0][3], 13.0f);
|
|
EXPECT_FLOAT_EQ(result.Elements[1][0], 2.0f);
|
|
EXPECT_FLOAT_EQ(result.Elements[1][1], 6.0f);
|
|
EXPECT_FLOAT_EQ(result.Elements[1][2], 10.0f);
|
|
EXPECT_FLOAT_EQ(result.Elements[1][3], 14.0f);
|
|
EXPECT_FLOAT_EQ(result.Elements[2][0], 3.0f);
|
|
EXPECT_FLOAT_EQ(result.Elements[2][1], 7.0f);
|
|
EXPECT_FLOAT_EQ(result.Elements[2][2], 11.0f);
|
|
EXPECT_FLOAT_EQ(result.Elements[2][3], 15.0f);
|
|
EXPECT_FLOAT_EQ(result.Elements[3][0], 4.0f);
|
|
EXPECT_FLOAT_EQ(result.Elements[3][1], 8.0f);
|
|
EXPECT_FLOAT_EQ(result.Elements[3][2], 12.0f);
|
|
EXPECT_FLOAT_EQ(result.Elements[3][3], 16.0f);
|
|
}
|