mirrors/HandmadeMath
1
0
Fork 0
mirror of https://github.com/HandmadeMath/HandmadeMath.git synced 2025-09-07 10:48:17 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
c24e4ff8737a4608609fe7f9c708e8e8a24e92fe
HandmadeMath/test/categories/Initialization.h
Logan Forman c24e4ff873 HMM2.0 (#149) 
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
2023-01-22 17:34:50 -06:00

247 lines
7.7 KiB
C
Raw Blame History

#include "../HandmadeTest.h"
TEST(Initialization, Vectors)
{
//
// Test vec2
//
HMM_Vec2 v2 = HMM_V2(1.0f, 2.0f);
HMM_Vec2 v2i = HMM_V2I(1, 2);
EXPECT_FLOAT_EQ(v2.X, 1.0f);
EXPECT_FLOAT_EQ(v2.Y, 2.0f);
EXPECT_FLOAT_EQ(v2.U, 1.0f);
EXPECT_FLOAT_EQ(v2.V, 2.0f);
EXPECT_FLOAT_EQ(v2.Left, 1.0f);
EXPECT_FLOAT_EQ(v2.Right, 2.0f);
EXPECT_FLOAT_EQ(v2.Width, 1.0f);
EXPECT_FLOAT_EQ(v2.Height, 2.0f);
EXPECT_FLOAT_EQ(v2.Elements[0], 1.0f);
EXPECT_FLOAT_EQ(v2.Elements[1], 2.0f);
#ifdef __cplusplus
EXPECT_FLOAT_EQ(v2[0], 1.0f);
EXPECT_FLOAT_EQ(v2[1], 2.0f);
#endif
EXPECT_FLOAT_EQ(v2i.X, 1.0f);
EXPECT_FLOAT_EQ(v2i.Y, 2.0f);
EXPECT_FLOAT_EQ(v2i.U, 1.0f);
EXPECT_FLOAT_EQ(v2i.V, 2.0f);
EXPECT_FLOAT_EQ(v2i.Left, 1.0f);
EXPECT_FLOAT_EQ(v2i.Right, 2.0f);
EXPECT_FLOAT_EQ(v2i.Width, 1.0f);
EXPECT_FLOAT_EQ(v2i.Height, 2.0f);
EXPECT_FLOAT_EQ(v2i.Elements[0], 1.0f);
EXPECT_FLOAT_EQ(v2i.Elements[1], 2.0f);
#ifdef __cplusplus
EXPECT_FLOAT_EQ(v2i[0], 1.0f);
EXPECT_FLOAT_EQ(v2i[1], 2.0f);
#endif
//
// Test vec3
//
HMM_Vec3 v3 = HMM_V3(1.0f, 2.0f, 3.0f);
HMM_Vec3 v3i = HMM_V3I(1, 2, 3);
EXPECT_FLOAT_EQ(v3.X, 1.0f);
EXPECT_FLOAT_EQ(v3.Y, 2.0f);
EXPECT_FLOAT_EQ(v3.Z, 3.0f);
EXPECT_FLOAT_EQ(v3.U, 1.0f);
EXPECT_FLOAT_EQ(v3.V, 2.0f);
EXPECT_FLOAT_EQ(v3.W, 3.0f);
EXPECT_FLOAT_EQ(v3.R, 1.0f);
EXPECT_FLOAT_EQ(v3.G, 2.0f);
EXPECT_FLOAT_EQ(v3.B, 3.0f);
EXPECT_FLOAT_EQ(v3.Elements[0], 1.0f);
EXPECT_FLOAT_EQ(v3.Elements[1], 2.0f);
EXPECT_FLOAT_EQ(v3.Elements[2], 3.0f);
EXPECT_FLOAT_EQ(v3.XY.Elements[0], 1.0f);
EXPECT_FLOAT_EQ(v3.XY.Elements[1], 2.0f);
EXPECT_FLOAT_EQ(v3.YZ.Elements[0], 2.0f);
EXPECT_FLOAT_EQ(v3.YZ.Elements[1], 3.0f);
EXPECT_FLOAT_EQ(v3.UV.Elements[0], 1.0f);
EXPECT_FLOAT_EQ(v3.UV.Elements[1], 2.0f);
EXPECT_FLOAT_EQ(v3.VW.Elements[0], 2.0f);
EXPECT_FLOAT_EQ(v3.VW.Elements[1], 3.0f);
#ifdef __cplusplus
EXPECT_FLOAT_EQ(v3[0], 1.0f);
EXPECT_FLOAT_EQ(v3[1], 2.0f);
EXPECT_FLOAT_EQ(v3[2], 3.0f);
#endif
EXPECT_FLOAT_EQ(v3i.X, 1.0f);
EXPECT_FLOAT_EQ(v3i.Y, 2.0f);
EXPECT_FLOAT_EQ(v3i.Z, 3.0f);
EXPECT_FLOAT_EQ(v3i.U, 1.0f);
EXPECT_FLOAT_EQ(v3i.V, 2.0f);
EXPECT_FLOAT_EQ(v3i.W, 3.0f);
EXPECT_FLOAT_EQ(v3i.R, 1.0f);
EXPECT_FLOAT_EQ(v3i.G, 2.0f);
EXPECT_FLOAT_EQ(v3i.B, 3.0f);
EXPECT_FLOAT_EQ(v3i.Elements[0], 1.0f);
EXPECT_FLOAT_EQ(v3i.Elements[1], 2.0f);
EXPECT_FLOAT_EQ(v3i.Elements[2], 3.0f);
EXPECT_FLOAT_EQ(v3i.XY.Elements[0], 1.0f);
EXPECT_FLOAT_EQ(v3i.XY.Elements[1], 2.0f);
EXPECT_FLOAT_EQ(v3i.YZ.Elements[0], 2.0f);
EXPECT_FLOAT_EQ(v3i.YZ.Elements[1], 3.0f);
EXPECT_FLOAT_EQ(v3i.UV.Elements[0], 1.0f);
EXPECT_FLOAT_EQ(v3i.UV.Elements[1], 2.0f);
EXPECT_FLOAT_EQ(v3i.VW.Elements[0], 2.0f);
EXPECT_FLOAT_EQ(v3i.VW.Elements[1], 3.0f);
#ifdef __cplusplus
EXPECT_FLOAT_EQ(v3i[0], 1.0f);
EXPECT_FLOAT_EQ(v3i[1], 2.0f);
EXPECT_FLOAT_EQ(v3i[2], 3.0f);
#endif
//
// Test vec4
//
HMM_Vec4 v4 = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
HMM_Vec4 v4i = HMM_V4I(1, 2, 3, 4);
HMM_Vec4 v4v = HMM_V4V(v3, 4.0f);
EXPECT_FLOAT_EQ(v4.X, 1.0f);
EXPECT_FLOAT_EQ(v4.Y, 2.0f);
EXPECT_FLOAT_EQ(v4.Z, 3.0f);
EXPECT_FLOAT_EQ(v4.W, 4.0f);
EXPECT_FLOAT_EQ(v4.R, 1.0f);
EXPECT_FLOAT_EQ(v4.G, 2.0f);
EXPECT_FLOAT_EQ(v4.B, 3.0f);
EXPECT_FLOAT_EQ(v4.A, 4.0f);
EXPECT_FLOAT_EQ(v4.XY.Elements[0], 1.0f);
EXPECT_FLOAT_EQ(v4.XY.Elements[1], 2.0f);
EXPECT_FLOAT_EQ(v4.YZ.Elements[0], 2.0f);
EXPECT_FLOAT_EQ(v4.YZ.Elements[1], 3.0f);
EXPECT_FLOAT_EQ(v4.ZW.Elements[0], 3.0f);
EXPECT_FLOAT_EQ(v4.ZW.Elements[1], 4.0f);
EXPECT_FLOAT_EQ(v4.XY.Elements[0], 1.0f);
EXPECT_FLOAT_EQ(v4.XY.Elements[1], 2.0f);
EXPECT_FLOAT_EQ(v4.XYZ.Elements[0], 1.0f);
EXPECT_FLOAT_EQ(v4.XYZ.Elements[1], 2.0f);
EXPECT_FLOAT_EQ(v4.XYZ.Elements[2], 3.0f);
EXPECT_FLOAT_EQ(v4.RGB.Elements[0], 1.0f);
EXPECT_FLOAT_EQ(v4.RGB.Elements[1], 2.0f);
EXPECT_FLOAT_EQ(v4.RGB.Elements[2], 3.0f);
#ifdef __cplusplus
EXPECT_FLOAT_EQ(v4[0], 1.0f);
EXPECT_FLOAT_EQ(v4[1], 2.0f);
EXPECT_FLOAT_EQ(v4[2], 3.0f);
EXPECT_FLOAT_EQ(v4[3], 4.0f);
#endif
EXPECT_FLOAT_EQ(v4i.X, 1.0f);
EXPECT_FLOAT_EQ(v4i.Y, 2.0f);
EXPECT_FLOAT_EQ(v4i.Z, 3.0f);
EXPECT_FLOAT_EQ(v4i.W, 4.0f);
EXPECT_FLOAT_EQ(v4i.R, 1.0f);
EXPECT_FLOAT_EQ(v4i.G, 2.0f);
EXPECT_FLOAT_EQ(v4i.B, 3.0f);
EXPECT_FLOAT_EQ(v4i.A, 4.0f);
EXPECT_FLOAT_EQ(v4i.XY.Elements[0], 1.0f);
EXPECT_FLOAT_EQ(v4i.XY.Elements[1], 2.0f);
EXPECT_FLOAT_EQ(v4i.YZ.Elements[0], 2.0f);
EXPECT_FLOAT_EQ(v4i.YZ.Elements[1], 3.0f);
EXPECT_FLOAT_EQ(v4i.ZW.Elements[0], 3.0f);
EXPECT_FLOAT_EQ(v4i.ZW.Elements[1], 4.0f);
EXPECT_FLOAT_EQ(v4i.XY.Elements[0], 1.0f);
EXPECT_FLOAT_EQ(v4i.XY.Elements[1], 2.0f);
EXPECT_FLOAT_EQ(v4i.XYZ.Elements[0], 1.0f);
EXPECT_FLOAT_EQ(v4i.XYZ.Elements[1], 2.0f);
EXPECT_FLOAT_EQ(v4i.XYZ.Elements[2], 3.0f);
EXPECT_FLOAT_EQ(v4i.RGB.Elements[0], 1.0f);
EXPECT_FLOAT_EQ(v4i.RGB.Elements[1], 2.0f);
EXPECT_FLOAT_EQ(v4i.RGB.Elements[2], 3.0f);
#ifdef __cplusplus
EXPECT_FLOAT_EQ(v4i[0], 1.0f);
EXPECT_FLOAT_EQ(v4i[1], 2.0f);
EXPECT_FLOAT_EQ(v4i[2], 3.0f);
EXPECT_FLOAT_EQ(v4i[3], 4.0f);
#endif
EXPECT_FLOAT_EQ(v4v.X, 1.0f);
EXPECT_FLOAT_EQ(v4v.Y, 2.0f);
EXPECT_FLOAT_EQ(v4v.Z, 3.0f);
EXPECT_FLOAT_EQ(v4v.W, 4.0f);
EXPECT_FLOAT_EQ(v4v.R, 1.0f);
EXPECT_FLOAT_EQ(v4v.G, 2.0f);
EXPECT_FLOAT_EQ(v4v.B, 3.0f);
EXPECT_FLOAT_EQ(v4v.A, 4.0f);
EXPECT_FLOAT_EQ(v4v.XY.Elements[0], 1.0f);
EXPECT_FLOAT_EQ(v4v.XY.Elements[1], 2.0f);
EXPECT_FLOAT_EQ(v4v.YZ.Elements[0], 2.0f);
EXPECT_FLOAT_EQ(v4v.YZ.Elements[1], 3.0f);
EXPECT_FLOAT_EQ(v4v.ZW.Elements[0], 3.0f);
EXPECT_FLOAT_EQ(v4v.ZW.Elements[1], 4.0f);
EXPECT_FLOAT_EQ(v4v.XY.Elements[0], 1.0f);
EXPECT_FLOAT_EQ(v4v.XY.Elements[1], 2.0f);
EXPECT_FLOAT_EQ(v4v.XYZ.Elements[0], 1.0f);
EXPECT_FLOAT_EQ(v4v.XYZ.Elements[1], 2.0f);
EXPECT_FLOAT_EQ(v4v.XYZ.Elements[2], 3.0f);
EXPECT_FLOAT_EQ(v4v.RGB.Elements[0], 1.0f);
EXPECT_FLOAT_EQ(v4v.RGB.Elements[1], 2.0f);
EXPECT_FLOAT_EQ(v4v.RGB.Elements[2], 3.0f);
#ifdef __cplusplus
EXPECT_FLOAT_EQ(v4v[0], 1.0f);
EXPECT_FLOAT_EQ(v4v[1], 2.0f);
EXPECT_FLOAT_EQ(v4v[2], 3.0f);
EXPECT_FLOAT_EQ(v4v[3], 4.0f);
#endif
}
TEST(Initialization, MatrixEmpty)
{
HMM_Mat4 m4 = HMM_M4();
for (int Column = 0; Column < 4; ++Column)
{
for (int Row = 0; Row < 4; ++Row)
{
EXPECT_FLOAT_EQ(m4.Elements[Column][Row], 0.0f);
#ifdef __cplusplus
EXPECT_FLOAT_EQ(m4[Column][Row], 0.0f);
#endif
}
}
}
TEST(Initialization, MatrixDiagonal)
{
HMM_Mat4 m4d = HMM_M4D(1.0f);
for (int Column = 0; Column < 4; ++Column)
{
for (int Row = 0; Row < 4; ++Row)
{
if (Column == Row) {
EXPECT_FLOAT_EQ(m4d.Elements[Column][Row], 1.0f);
} else {
EXPECT_FLOAT_EQ(m4d.Elements[Column][Row], 0.0f);
}
}
}
}
TEST(Initialization, Quaternion)
{
HMM_Quat q = HMM_Q(1.0f, 2.0f, 3.0f, 4.0f);
EXPECT_FLOAT_EQ(q.X, 1.0f);
EXPECT_FLOAT_EQ(q.Y, 2.0f);
EXPECT_FLOAT_EQ(q.Z, 3.0f);
EXPECT_FLOAT_EQ(q.W, 4.0f);
EXPECT_FLOAT_EQ(q.Elements[0], 1.0f);
EXPECT_FLOAT_EQ(q.Elements[1], 2.0f);
EXPECT_FLOAT_EQ(q.Elements[2], 3.0f);
EXPECT_FLOAT_EQ(q.Elements[3], 4.0f);
HMM_Vec4 v = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
HMM_Quat qv = HMM_QV4(v);
EXPECT_FLOAT_EQ(qv.X, 1.0f);
EXPECT_FLOAT_EQ(qv.Y, 2.0f);
EXPECT_FLOAT_EQ(qv.Z, 3.0f);
EXPECT_FLOAT_EQ(qv.W, 4.0f);
}
Reference in New Issue View Git Blame Copy Permalink