bigboss/CosmicEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Ajout de Jolt Physics + 1ere version des factory entitecomposants - camera, transform, rigidbody, collider, renderer

Browse Source
This commit is contained in:
Tom Ray
2026-03-22 00:28:03 +01:00
parent 6695d46bcd
commit 48348936a8
1147 changed files with 214331 additions and 353 deletions
Download Patch File Download Diff File Expand all files Collapse all files

91
lib/All/JoltPhysics/UnitTests/Math/BVec16Tests.cpp Normal file
View File

@@ -0,0 +1,91 @@
// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2024 Jorrit Rouwe
// SPDX-License-Identifier: MIT
#include "UnitTestFramework.h"
#include <Jolt/Math/BVec16.h>
#include <Jolt/Core/StringTools.h>
TEST_SUITE("BVec16Tests")
{
TEST_CASE("TestBVec16Construct")
{
BVec16 v(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
CHECK(v[0] == 1);
CHECK(v[1] == 2);
CHECK(v[2] == 3);
CHECK(v[3] == 4);
CHECK(v[4] == 5);
CHECK(v[5] == 6);
CHECK(v[6] == 7);
CHECK(v[7] == 8);
CHECK(v[8] == 9);
CHECK(v[9] == 10);
CHECK(v[10] == 11);
CHECK(v[11] == 12);
CHECK(v[12] == 13);
CHECK(v[13] == 14);
CHECK(v[14] == 15);
CHECK(v[15] == 16);
// Test == and != operators
CHECK(v == BVec16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16));
CHECK(v != BVec16(1, 2, 3, 4, 5, 6, 7, 8, 10, 9, 11, 12, 13, 14, 15, 16));
// Check element modification
CHECK(const_cast<const BVec16 &>(v)[15] == 16); // Check const operator
v[15] = 17;
CHECK(v[15] == 17);
CHECK(v == BVec16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17));
}
TEST_CASE("TestBVec16LoadByte16")
{
uint8 u16[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
CHECK(BVec16::sLoadByte16(u16) == BVec16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16));
}
TEST_CASE("TestBVec16Zero")
{
BVec16 v = BVec16::sZero();
for (int i = 0; i < 16; ++i)
CHECK(v[i] == 0);
}
TEST_CASE("TestBVec16Replicate")
{
CHECK(BVec16::sReplicate(2) == BVec16(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2));
}
TEST_CASE("TestBVec16Comparisons")
{
BVec16 eq = BVec16::sEquals(BVec16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), BVec16(6, 7, 3, 4, 5, 6, 7, 5, 9, 10, 11, 12, 13, 14, 15, 13));
CHECK(eq.GetTrues() == 0b0111111101111100);
CHECK(eq.TestAnyTrue());
CHECK(!eq.TestAllTrue());
}
TEST_CASE("TestBVec16BitOps")
{
// Test all bit permutations
BVec16 v1(0b011, 0b0110, 0b01100, 0b011000, 0b0110000, 0b01100000, 0b011, 0b0110, 0b01100, 0b011000, 0b0110000, 0b01100000, 0b011, 0b0110, 0b01100, 0b011000);
BVec16 v2(0b101, 0b1010, 0b10100, 0b101000, 0b1010000, 0b10100000, 0b101, 0b1010, 0b10100, 0b101000, 0b1010000, 0b10100000, 0b101, 0b1010, 0b10100, 0b101000);
CHECK(BVec16::sOr(v1, v2) == BVec16(0b111, 0b1110, 0b11100, 0b111000, 0b1110000, 0b11100000, 0b111, 0b1110, 0b11100, 0b111000, 0b1110000, 0b11100000, 0b111, 0b1110, 0b11100, 0b111000));
CHECK(BVec16::sXor(v1, v2) == BVec16(0b110, 0b1100, 0b11000, 0b110000, 0b1100000, 0b11000000, 0b110, 0b1100, 0b11000, 0b110000, 0b1100000, 0b11000000, 0b110, 0b1100, 0b11000, 0b110000));
CHECK(BVec16::sAnd(v1, v2) == BVec16(0b001, 0b0010, 0b00100, 0b001000, 0b0010000, 0b00100000, 0b001, 0b0010, 0b00100, 0b001000, 0b0010000, 0b00100000, 0b001, 0b0010, 0b00100, 0b001000));
CHECK(BVec16::sNot(v1) == BVec16(0b11111100, 0b11111001, 0b11110011, 0b11100111, 0b11001111, 0b10011111, 0b11111100, 0b11111001, 0b11110011, 0b11100111, 0b11001111, 0b10011111, 0b11111100, 0b11111001, 0b11110011, 0b11100111));
CHECK(BVec16::sNot(v2) == BVec16(0b11111010, 0b11110101, 0b11101011, 0b11010111, 0b10101111, 0b01011111, 0b11111010, 0b11110101, 0b11101011, 0b11010111, 0b10101111, 0b01011111, 0b11111010, 0b11110101, 0b11101011, 0b11010111));
}
TEST_CASE("TestBVec16ToString")
{
BVec16 v(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
CHECK(ConvertToString(v) == "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16");
}
}

246
lib/All/JoltPhysics/UnitTests/Math/DMat44Tests.cpp Normal file
View File

@@ -0,0 +1,246 @@
// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2022 Jorrit Rouwe
// SPDX-License-Identifier: MIT
#include "UnitTestFramework.h"
#include <Jolt/Math/DMat44.h>
#include <Jolt/Core/StringTools.h>
TEST_SUITE("DMat44Tests")
{
TEST_CASE("TestDMat44Zero")
{
DMat44 zero = DMat44::sZero();
CHECK(zero == DMat44(Vec4(0, 0, 0, 0), Vec4(0, 0, 0, 0), Vec4(0, 0, 0, 0), DVec3(0, 0, 0)));
CHECK(zero.GetAxisX() == Vec3::sZero());
CHECK(zero.GetAxisY() == Vec3::sZero());
CHECK(zero.GetAxisZ() == Vec3::sZero());
CHECK(zero.GetTranslation() == DVec3::sZero());
}
TEST_CASE("TestDMat44Identity")
{
DMat44 identity = DMat44::sIdentity();
CHECK(identity == DMat44(Vec4(1, 0, 0, 0), Vec4(0, 1, 0, 0), Vec4(0, 0, 1, 0), DVec3(0, 0, 0)));
// Check non-equality
CHECK(identity != DMat44(Vec4(0, 0, 0, 0), Vec4(0, 1, 0, 0), Vec4(0, 0, 1, 0), DVec3(0, 0, 0)));
CHECK(identity != DMat44(Vec4(1, 0, 0, 0), Vec4(0, 0, 0, 0), Vec4(0, 0, 1, 0), DVec3(0, 0, 0)));
CHECK(identity != DMat44(Vec4(1, 0, 0, 0), Vec4(0, 1, 0, 0), Vec4(0, 0, 0, 0), DVec3(0, 0, 0)));
CHECK(identity != DMat44(Vec4(1, 0, 0, 0), Vec4(0, 1, 0, 0), Vec4(0, 0, 1, 0), DVec3(1, 0, 0)));
}
TEST_CASE("TestDMat44Construct")
{
DMat44 mat(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), DVec3(13, 14, 15));
CHECK(mat.GetColumn4(0) == Vec4(1, 2, 3, 4));
CHECK(mat.GetColumn4(1) == Vec4(5, 6, 7, 8));
CHECK(mat.GetColumn4(2) == Vec4(9, 10, 11, 12));
CHECK(mat.GetTranslation() == DVec3(13, 14, 15));
DMat44 mat2(mat);
CHECK(mat2.GetColumn4(0) == Vec4(1, 2, 3, 4));
CHECK(mat2.GetColumn4(1) == Vec4(5, 6, 7, 8));
CHECK(mat2.GetColumn4(2) == Vec4(9, 10, 11, 12));
CHECK(mat2.GetTranslation() == DVec3(13, 14, 15));
}
TEST_CASE("TestDMat44Scale")
{
CHECK(DMat44::sScale(Vec3(2, 3, 4)) == DMat44(Vec4(2, 0, 0, 0), Vec4(0, 3, 0, 0), Vec4(0, 0, 4, 0), DVec3(0, 0, 0)));
}
TEST_CASE("TestDMat44Rotation")
{
DMat44 mat(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), DVec3(13, 14, 15));
CHECK(mat.GetRotation() == Mat44(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), Vec4(0, 0, 0, 1)));
}
TEST_CASE("TestMat44SetRotation")
{
DMat44 mat(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), DVec3(13, 14, 15));
Mat44 mat2(Vec4(17, 18, 19, 20), Vec4(21, 22, 23, 24), Vec4(25, 26, 27, 28), Vec4(29, 30, 31, 32));
mat.SetRotation(mat2);
CHECK(mat == DMat44(Vec4(17, 18, 19, 20), Vec4(21, 22, 23, 24), Vec4(25, 26, 27, 28), DVec3(13, 14, 15)));
}
TEST_CASE("TestDMat44Rotation")
{
Quat q = Quat::sRotation(Vec3(1, 1, 1).Normalized(), 0.2f * JPH_PI);
CHECK(DMat44::sRotation(q).ToMat44() == Mat44::sRotation(q));
}
TEST_CASE("TestDMat44Translation")
{
CHECK(DMat44::sTranslation(DVec3(1, 2, 3)) == DMat44(Vec4(1, 0, 0, 0), Vec4(0, 1, 0, 0), Vec4(0, 0, 1, 0), DVec3(1, 2, 3)));
}
TEST_CASE("TestDMat44RotationTranslation")
{
Quat q = Quat::sRotation(Vec3(1, 1, 1).Normalized(), 0.2f * JPH_PI);
CHECK(DMat44::sRotationTranslation(q, DVec3(1, 2, 3)).ToMat44() == Mat44::sRotationTranslation(q, Vec3(1, 2, 3)));
}
TEST_CASE("TestDMat44MultiplyMat44")
{
DMat44 mat(Vec4(1, 2, 3, 0), Vec4(5, 6, 7, 0), Vec4(9, 10, 11, 0), DVec3(13, 14, 15));
Mat44 mat2(Vec4(17, 18, 19, 0), Vec4(21, 22, 23, 0), Vec4(25, 26, 27, 0), Vec4(29, 30, 31, 1));
DMat44 result = mat * mat2;
CHECK(result == DMat44(Vec4(278, 332, 386, 0), Vec4(338, 404, 470, 0), Vec4(398, 476, 554, 0), DVec3(471, 562, 653)));
}
TEST_CASE("TestDMat44MultiplyDMat44")
{
DMat44 mat(Vec4(1, 2, 3, 0), Vec4(5, 6, 7, 0), Vec4(9, 10, 11, 0), DVec3(13, 14, 15));
DMat44 mat2(Vec4(17, 18, 19, 0), Vec4(21, 22, 23, 0), Vec4(25, 26, 27, 0), DVec3(29, 30, 31));
DMat44 result = mat * mat2;
CHECK(result == DMat44(Vec4(278, 332, 386, 0), Vec4(338, 404, 470, 0), Vec4(398, 476, 554, 0), DVec3(471, 562, 653)));
}
TEST_CASE("TestDMat44MultiplyVec3")
{
DMat44 mat(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), DVec3(13, 14, 15));
Vec3 vec(17, 18, 19);
DVec3 result = mat * DVec3(vec);
CHECK(result == DVec3(291, 346, 401));
DVec3 result2 = mat * vec;
CHECK(result2 == DVec3(291, 346, 401));
Vec3 result3 = mat.Multiply3x3(vec);
CHECK(result3 == Vec3(278, 332, 386));
Vec3 result4 = mat.Multiply3x3Transposed(vec);
CHECK(result4 == Vec3(110, 326, 542));
}
TEST_CASE("TestDMat44Inversed")
{
DMat44 mat(Vec4(1, 16, 2, 0), Vec4(2, 8, 4, 0), Vec4(8, 4, 1, 0), DVec3(4, 2, 8));
DMat44 inverse = mat.Inversed();
DMat44 identity = mat * inverse;
CHECK_APPROX_EQUAL(identity, DMat44::sIdentity());
}
TEST_CASE("TestDMat44InverseRotateTranslate")
{
Quat rot = Quat::sRotation(Vec3(0, 1, 0), 0.2f * JPH_PI);
DVec3 pos(2, 3, 4);
DMat44 m1 = DMat44::sRotationTranslation(rot, pos).Inversed();
DMat44 m2 = DMat44::sInverseRotationTranslation(rot, pos);
CHECK_APPROX_EQUAL(m1, m2);
}
TEST_CASE("TestDMat44InversedRotationTranslation")
{
Quat rot = Quat::sRotation(Vec3(0, 1, 0), 0.2f * JPH_PI);
DVec3 pos(2, 3, 4);
DMat44 m1 = DMat44::sRotationTranslation(rot, pos).InversedRotationTranslation();
DMat44 m2 = DMat44::sInverseRotationTranslation(rot, pos);
CHECK_APPROX_EQUAL(m1, m2);
}
TEST_CASE("TestDMat44PrePostScaled")
{
DMat44 m(Vec4(2, 3, 4, 0), Vec4(5, 6, 7, 0), Vec4(8, 9, 10, 0), DVec3(11, 12, 13));
Vec3 v(14, 15, 16);
CHECK(m.PreScaled(v) == m * DMat44::sScale(v));
CHECK(m.PostScaled(v) == DMat44::sScale(v) * m);
}
TEST_CASE("TestDMat44PrePostTranslated")
{
DMat44 m(Vec4(2, 3, 4, 0), Vec4(5, 6, 7, 0), Vec4(8, 9, 10, 0), DVec3(11, 12, 13));
Vec3 v(14, 15, 16);
CHECK_APPROX_EQUAL(m.PreTranslated(v), m * DMat44::sTranslation(DVec3(v)));
CHECK_APPROX_EQUAL(m.PostTranslated(v), DMat44::sTranslation(DVec3(v)) * m);
}
TEST_CASE("TestDMat44Decompose")
{
// Create a rotation/translation matrix
Quat rot = Quat::sRotation(Vec3(1, 1, 1).Normalized(), 0.2f * JPH_PI);
DVec3 pos(2, 3, 4);
DMat44 rotation_translation = DMat44::sRotationTranslation(rot, pos);
// Scale the matrix
Vec3 scale(2, 1, 3);
DMat44 m1 = rotation_translation * DMat44::sScale(scale);
// Decompose scale
Vec3 scale_out;
DMat44 m2 = m1.Decompose(scale_out);
// Check individual components
CHECK_APPROX_EQUAL(rotation_translation, m2);
CHECK_APPROX_EQUAL(scale, scale_out);
}
TEST_CASE("TestDMat44ToMat44")
{
DMat44 mat(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), DVec3(13, 14, 15));
CHECK(mat.ToMat44() == Mat44(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), Vec4(13, 14, 15, 1)));
}
TEST_CASE("TestDMat44Column")
{
DMat44 mat = DMat44::sZero();
mat.SetColumn4(0, Vec4(1, 2, 3, 4));
CHECK(mat.GetColumn4(0) == Vec4(1, 2, 3, 4));
mat.SetColumn3(0, Vec3(5, 6, 7));
CHECK(mat.GetColumn3(0) == Vec3(5, 6, 7));
CHECK(mat.GetColumn4(0) == Vec4(5, 6, 7, 0));
mat.SetAxisX(Vec3(8, 9, 10));
mat.SetAxisY(Vec3(11, 12, 13));
mat.SetAxisZ(Vec3(14, 15, 16));
mat.SetTranslation(DVec3(17, 18, 19));
CHECK(mat.GetAxisX() == Vec3(8, 9, 10));
CHECK(mat.GetAxisY() == Vec3(11, 12, 13));
CHECK(mat.GetAxisZ() == Vec3(14, 15, 16));
CHECK(mat.GetTranslation() == DVec3(17, 18, 19));
}
TEST_CASE("TestDMat44Transposed")
{
DMat44 mat(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), DVec3(13, 14, 15));
Mat44 result = mat.Transposed3x3();
CHECK(result == Mat44(Vec4(1, 5, 9, 0), Vec4(2, 6, 10, 0), Vec4(3, 7, 11, 0), Vec4(0, 0, 0, 1)));
}
TEST_CASE("TestDMat44GetQuaternion")
{
Quat rot = Quat::sRotation(Vec3(1, 1, 1).Normalized(), 0.2f * JPH_PI);
DMat44 mat = DMat44::sRotation(rot);
CHECK_APPROX_EQUAL(mat.GetQuaternion(), rot);
}
TEST_CASE("TestDMat44PrePostTranslated")
{
DMat44 m(Vec4(2, 3, 4, 0), Vec4(5, 6, 7, 0), Vec4(8, 9, 10, 0), DVec3(11, 12, 13));
DVec3 v(14, 15, 16);
CHECK(m.PreTranslated(v) == m * DMat44::sTranslation(v));
CHECK(m.PostTranslated(v) == DMat44::sTranslation(v) * m);
}
TEST_CASE("TestDMat44ConvertToString")
{
DMat44 v(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), DVec3(13, 14, 15));
CHECK(ConvertToString(v) == "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15");
}
}

308
lib/All/JoltPhysics/UnitTests/Math/DVec3Tests.cpp Normal file
View File

@@ -0,0 +1,308 @@
// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
#include "UnitTestFramework.h"
#include <Jolt/Math/DVec3.h>
#include <Jolt/Core/StringTools.h>
TEST_SUITE("DVec3Tests")
{
TEST_CASE("TestDVec3Zero")
{
DVec3 v = DVec3::sZero();
CHECK(v.GetX() == 0);
CHECK(v.GetY() == 0);
CHECK(v.GetZ() == 0);
}
TEST_CASE("TestDVec3Axis")
{
CHECK(DVec3::sAxisX() == DVec3(1, 0, 0));
CHECK(DVec3::sAxisY() == DVec3(0, 1, 0));
CHECK(DVec3::sAxisZ() == DVec3(0, 0, 1));
}
TEST_CASE("TestVec3NaN")
{
DVec3 v = DVec3::sNaN();
CHECK(isnan(v.GetX()));
CHECK(isnan(v.GetY()));
CHECK(isnan(v.GetZ()));
CHECK(v.IsNaN());
v.SetComponent(0, 0);
CHECK(v.IsNaN());
v.SetComponent(1, 0);
CHECK(v.IsNaN());
v.SetComponent(2, 0);
CHECK(!v.IsNaN());
}
TEST_CASE("TestDVec3ConstructComponents")
{
DVec3 v(1, 2, 3);
// Test component access
CHECK(v.GetX() == 1);
CHECK(v.GetY() == 2);
CHECK(v.GetZ() == 3);
// Test component access by [] operators
CHECK(v[0] == 1);
CHECK(v[1] == 2);
CHECK(v[2] == 3);
// Test == and != operators
CHECK(v == DVec3(1, 2, 3));
CHECK(v != DVec3(1, 2, 4));
// Set the components
v.SetComponent(0, 4);
v.SetComponent(1, 5);
v.SetComponent(2, 6);
CHECK(v == DVec3(4, 5, 6));
// Set the components again
v.SetX(7);
v.SetY(8);
v.SetZ(9);
CHECK(v == DVec3(7, 8, 9));
// Set all components
v.Set(10, 11, 12);
CHECK(v == DVec3(10, 11, 12));
}
TEST_CASE("TestVec4ToDVec3")
{
CHECK(DVec3(Vec4(1, 3, 5, 7)) == DVec3(1, 3, 5));
}
TEST_CASE("TestDVec3Replicate")
{
CHECK(DVec3::sReplicate(2) == DVec3(2, 2, 2));
}
TEST_CASE("TestDVec3ToVec3")
{
CHECK(Vec3(DVec3(1, 3, 5)) == Vec3(1, 3, 5));
// Check rounding up and down
CHECK(DVec3(2.0, 0x1.0000000000001p1, -0x1.0000000000001p1).ToVec3RoundUp() == Vec3(2.0, 0x1.000002p1f, -2.0));
CHECK(DVec3(2.0, 0x1.0000000000001p1, -0x1.0000000000001p1).ToVec3RoundDown() == Vec3(2.0, 2.0, -0x1.000002p1f));
}
TEST_CASE("TestVec3MinMax")
{
DVec3 v1(1, 5, 3);
DVec3 v2(4, 2, 6);
CHECK(DVec3::sMin(v1, v2) == DVec3(1, 2, 3));
CHECK(DVec3::sMax(v1, v2) == DVec3(4, 5, 6));
}
TEST_CASE("TestDVec3Clamp")
{
DVec3 v1(1, 2, 3);
DVec3 v2(4, 5, 6);
DVec3 v(-1, 3, 7);
CHECK(DVec3::sClamp(v, v1, v2) == DVec3(1, 3, 6));
}
TEST_CASE("TestDVec3Trues")
{
CHECK(DVec3(DVec3::cFalse, DVec3::cFalse, DVec3::cFalse).GetTrues() == 0b0000);
CHECK(DVec3(DVec3::cTrue, DVec3::cFalse, DVec3::cFalse).GetTrues() == 0b0001);
CHECK(DVec3(DVec3::cFalse, DVec3::cTrue, DVec3::cFalse).GetTrues() == 0b0010);
CHECK(DVec3(DVec3::cTrue, DVec3::cTrue, DVec3::cFalse).GetTrues() == 0b0011);
CHECK(DVec3(DVec3::cFalse, DVec3::cFalse, DVec3::cTrue).GetTrues() == 0b0100);
CHECK(DVec3(DVec3::cTrue, DVec3::cFalse, DVec3::cTrue).GetTrues() == 0b0101);
CHECK(DVec3(DVec3::cFalse, DVec3::cTrue, DVec3::cTrue).GetTrues() == 0b0110);
CHECK(DVec3(DVec3::cTrue, DVec3::cTrue, DVec3::cTrue).GetTrues() == 0b0111);
CHECK(!DVec3(DVec3::cFalse, DVec3::cFalse, DVec3::cFalse).TestAnyTrue());
CHECK(DVec3(DVec3::cTrue, DVec3::cFalse, DVec3::cFalse).TestAnyTrue());
CHECK(DVec3(DVec3::cFalse, DVec3::cTrue, DVec3::cFalse).TestAnyTrue());
CHECK(DVec3(DVec3::cTrue, DVec3::cTrue, DVec3::cFalse).TestAnyTrue());
CHECK(DVec3(DVec3::cFalse, DVec3::cFalse, DVec3::cTrue).TestAnyTrue());
CHECK(DVec3(DVec3::cTrue, DVec3::cFalse, DVec3::cTrue).TestAnyTrue());
CHECK(DVec3(DVec3::cFalse, DVec3::cTrue, DVec3::cTrue).TestAnyTrue());
CHECK(DVec3(DVec3::cTrue, DVec3::cTrue, DVec3::cTrue).TestAnyTrue());
CHECK(!DVec3(DVec3::cFalse, DVec3::cFalse, DVec3::cFalse).TestAllTrue());
CHECK(!DVec3(DVec3::cTrue, DVec3::cFalse, DVec3::cFalse).TestAllTrue());
CHECK(!DVec3(DVec3::cFalse, DVec3::cTrue, DVec3::cFalse).TestAllTrue());
CHECK(!DVec3(DVec3::cTrue, DVec3::cTrue, DVec3::cFalse).TestAllTrue());
CHECK(!DVec3(DVec3::cFalse, DVec3::cFalse, DVec3::cTrue).TestAllTrue());
CHECK(!DVec3(DVec3::cTrue, DVec3::cFalse, DVec3::cTrue).TestAllTrue());
CHECK(!DVec3(DVec3::cFalse, DVec3::cTrue, DVec3::cTrue).TestAllTrue());
CHECK(DVec3(DVec3::cTrue, DVec3::cTrue, DVec3::cTrue).TestAllTrue());
}
TEST_CASE("TestDVec3Comparisons")
{
CHECK(DVec3::sEquals(DVec3(1, 2, 3), DVec3(1, 4, 3)).GetTrues() == 0b101); // Can't directly check if equal to (true, false, true) because true = -NaN and -NaN != -NaN
CHECK(DVec3::sLess(DVec3(1, 2, 4), DVec3(1, 4, 3)).GetTrues() == 0b010);
CHECK(DVec3::sLessOrEqual(DVec3(1, 2, 4), DVec3(1, 4, 3)).GetTrues() == 0b011);
CHECK(DVec3::sGreater(DVec3(1, 2, 4), DVec3(1, 4, 3)).GetTrues() == 0b100);
CHECK(DVec3::sGreaterOrEqual(DVec3(1, 2, 4), DVec3(1, 4, 3)).GetTrues() == 0b101);
}
TEST_CASE("TestDVec3FMA")
{
CHECK(DVec3::sFusedMultiplyAdd(DVec3(1, 2, 3), DVec3(4, 5, 6), DVec3(7, 8, 9)) == DVec3(1 * 4 + 7, 2 * 5 + 8, 3 * 6 + 9));
}
TEST_CASE("TestDVec3Select")
{
const double cTrue2 = BitCast<double>(uint64(1) << 63);
const double cFalse2 = BitCast<double>(~uint64(0) >> 1);
CHECK(DVec3::sSelect(DVec3(1, 2, 3), DVec3(4, 5, 6), DVec3(DVec3::cTrue, DVec3::cFalse, DVec3::cTrue)) == DVec3(4, 2, 6));
CHECK(DVec3::sSelect(DVec3(1, 2, 3), DVec3(4, 5, 6), DVec3(DVec3::cFalse, DVec3::cTrue, DVec3::cFalse)) == DVec3(1, 5, 3));
CHECK(DVec3::sSelect(DVec3(1, 2, 3), DVec3(4, 5, 6), DVec3(cTrue2, cFalse2, cTrue2)) == DVec3(4, 2, 6));
CHECK(DVec3::sSelect(DVec3(1, 2, 3), DVec3(4, 5, 6), DVec3(cFalse2, cTrue2, cFalse2)) == DVec3(1, 5, 3));
}
TEST_CASE("TestDVec3BitOps")
{
// Test all bit permutations
DVec3 v1(BitCast<double, uint64>(0b0011), BitCast<double, uint64>(0b00110), BitCast<double, uint64>(0b001100));
DVec3 v2(BitCast<double, uint64>(0b0101), BitCast<double, uint64>(0b01010), BitCast<double, uint64>(0b010100));
CHECK(DVec3::sOr(v1, v2) == DVec3(BitCast<double, uint64>(0b0111), BitCast<double, uint64>(0b01110), BitCast<double, uint64>(0b011100)));
CHECK(DVec3::sXor(v1, v2) == DVec3(BitCast<double, uint64>(0b0110), BitCast<double, uint64>(0b01100), BitCast<double, uint64>(0b011000)));
CHECK(DVec3::sAnd(v1, v2) == DVec3(BitCast<double, uint64>(0b0001), BitCast<double, uint64>(0b00010), BitCast<double, uint64>(0b000100)));
}
TEST_CASE("TestDVec3Close")
{
CHECK(DVec3(1, 2, 3).IsClose(DVec3(1.001, 2.001, 3.001), 1.0e-4));
CHECK(!DVec3(1, 2, 3).IsClose(DVec3(1.001, 2.001, 3.001), 1.0e-6));
CHECK(DVec3(1.001, 0, 0).IsNormalized(1.0e-2));
CHECK(!DVec3(0, 1.001, 0).IsNormalized(1.0e-4));
CHECK(DVec3(-1.0e-7, 1.0e-7, 1.0e-8).IsNearZero(1.0e-12));
CHECK(!DVec3(-1.0e-7, 1.0e-7, -1.0e-5).IsNearZero(1.0e-12));
}
TEST_CASE("TestDVec3Operators")
{
CHECK(-DVec3(1, 2, 3) == DVec3(-1, -2, -3));
DVec3 neg_zero = -DVec3::sZero();
CHECK(neg_zero == DVec3::sZero());
#ifdef JPH_CROSS_PLATFORM_DETERMINISTIC
// When cross platform deterministic, we want to make sure that -0 is represented as 0
CHECK(BitCast<uint64>(neg_zero.GetX()) == 0);
CHECK(BitCast<uint64>(neg_zero.GetY()) == 0);
CHECK(BitCast<uint64>(neg_zero.GetZ()) == 0);
#endif // JPH_CROSS_PLATFORM_DETERMINISTIC
CHECK(DVec3(1, 2, 3) + Vec3(4, 5, 6) == DVec3(5, 7, 9));
CHECK(DVec3(1, 2, 3) - Vec3(6, 5, 4) == DVec3(-5, -3, -1));
CHECK(DVec3(1, 2, 3) + DVec3(4, 5, 6) == DVec3(5, 7, 9));
CHECK(DVec3(1, 2, 3) - DVec3(6, 5, 4) == DVec3(-5, -3, -1));
CHECK(DVec3(1, 2, 3) * DVec3(4, 5, 6) == DVec3(4, 10, 18));
CHECK(DVec3(1, 2, 3) * 2 == DVec3(2, 4, 6));
CHECK(4 * DVec3(1, 2, 3) == DVec3(4, 8, 12));
CHECK(DVec3(1, 2, 3) / 2 == DVec3(0.5, 1.0, 1.5));
CHECK(DVec3(1, 2, 3) / DVec3(2, 8, 24) == DVec3(0.5, 0.25, 0.125));
DVec3 v = DVec3(1, 2, 3);
v *= DVec3(4, 5, 6);
CHECK(v == DVec3(4, 10, 18));
v *= 2;
CHECK(v == DVec3(8, 20, 36));
v /= 2;
CHECK(v == DVec3(4, 10, 18));
v += DVec3(1, 2, 3);
CHECK(v == DVec3(5, 12, 21));
v -= DVec3(1, 2, 3);
CHECK(v == DVec3(4, 10, 18));
v += Vec3(1, 2, 3);
CHECK(v == DVec3(5, 12, 21));
v -= Vec3(1, 2, 3);
CHECK(v == DVec3(4, 10, 18));
CHECK(DVec3(2, 4, 8).Reciprocal() == DVec3(0.5, 0.25, 0.125));
}
TEST_CASE("TestDVec3Abs")
{
CHECK(DVec3(1, -2, 3).Abs() == DVec3(1, 2, 3));
CHECK(DVec3(-1, 2, -3).Abs() == DVec3(1, 2, 3));
}
TEST_CASE("TestDVec3Dot")
{
CHECK(DVec3(2, 3, 4).Dot(DVec3(5, 6, 7)) == double(2 * 5 + 3 * 6 + 4 * 7));
}
TEST_CASE("TestDVec3Length")
{
CHECK(DVec3(2, 3, 4).LengthSq() == double(4 + 9 + 16));
CHECK(DVec3(2, 3, 4).Length() == sqrt(double(4 + 9 + 16)));
}
TEST_CASE("TestDVec3Sqrt")
{
CHECK(DVec3(13, 15, 17).Sqrt() == DVec3(sqrt(13.0), sqrt(15.0), sqrt(17.0)));
}
TEST_CASE("TestDVec3Equals")
{
CHECK_FALSE(DVec3(13, 15, 17) == DVec3(13, 15, 19));
CHECK(DVec3(13, 15, 17) == DVec3(13, 15, 17));
CHECK(DVec3(13, 15, 17) != DVec3(13, 15, 19));
}
TEST_CASE("TestDVec3LoadStoreDouble3Unsafe")
{
double d4[4] = { 1, 2, 3, 4 };
Double3 &d3 = *(Double3 *)d4;
DVec3 v = DVec3::sLoadDouble3Unsafe(d3);
DVec3 v2(1, 2, 3);
CHECK(v == v2);
Double3 d3_out;
DVec3(1, 2, 3).StoreDouble3(&d3_out);
CHECK(d3 == d3_out);
}
TEST_CASE("TestDVec3Cross")
{
CHECK(DVec3(1, 0, 0).Cross(DVec3(0, 1, 0)) == DVec3(0, 0, 1));
CHECK(DVec3(0, 1, 0).Cross(DVec3(1, 0, 0)) == DVec3(0, 0, -1));
CHECK(DVec3(0, 1, 0).Cross(DVec3(0, 0, 1)) == DVec3(1, 0, 0));
CHECK(DVec3(0, 0, 1).Cross(DVec3(0, 1, 0)) == DVec3(-1, 0, 0));
CHECK(DVec3(0, 0, 1).Cross(DVec3(1, 0, 0)) == DVec3(0, 1, 0));
CHECK(DVec3(1, 0, 0).Cross(DVec3(0, 0, 1)) == DVec3(0, -1, 0));
}
TEST_CASE("TestDVec3Normalize")
{
CHECK(DVec3(3, 2, 1).Normalized() == DVec3(3, 2, 1) / sqrt(9.0 + 4.0 + 1.0));
}
TEST_CASE("TestDVec3Sign")
{
CHECK(DVec3(1.2345, -6.7891, 0).GetSign() == DVec3(1, -1, 1));
CHECK(DVec3(0, 2.3456, -7.8912).GetSign() == DVec3(1, 1, -1));
}
TEST_CASE("TestDVec3ConvertToString")
{
DVec3 v(1, 2, 3);
CHECK(ConvertToString(v) == "1, 2, 3");
}
}

57
lib/All/JoltPhysics/UnitTests/Math/EigenValueSymmetricTests.cpp Normal file
View File

@@ -0,0 +1,57 @@
// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2024 Jorrit Rouwe
// SPDX-License-Identifier: MIT
#include "UnitTestFramework.h"
#include <Jolt/Math/EigenValueSymmetric.h>
#include <Jolt/Math/Matrix.h>
TEST_SUITE("EigenValueSymmetricTests")
{
TEST_CASE("TestEigenValueSymmetric")
{
UnitTestRandom random;
uniform_real_distribution<float> angle_distribution(0, 2.0f * JPH_PI);
uniform_real_distribution<float> scale_distribution(0.1f, 10.0f);
for (int i = 0; i < 1000; ++i)
{
// Random scale vector
Vec3 scale(scale_distribution(random), scale_distribution(random), scale_distribution(random));
// Random rotation matrix
Mat44 rotation = Mat44::sRotation(Vec3::sRandom(random), angle_distribution(random));
// Construct a symmetric tensor from this rotation and scale
Mat44 tensor4 = rotation.Multiply3x3(Mat44::sScale(scale)).Multiply3x3RightTransposed(rotation);
// Get the eigenvalues and eigenvectors
Matrix<3, 3> tensor;
Matrix<3, 3> eigen_vec = Matrix<3, 3>::sIdentity();
Vector<3> eigen_val;
tensor.CopyPart(tensor4, 0, 0, 3, 3, 0, 0);
CHECK(EigenValueSymmetric(tensor, eigen_vec, eigen_val));
for (int c = 0; c < 3; ++c)
{
// Check that we found a valid eigenvalue
bool found = false;
for (int c2 = 0; c2 < 3; ++c2)
if (abs(scale[c2] - eigen_val[c]) < 1.0e-5f)
{
found = true;
break;
}
CHECK(found);
// Check if the eigenvector is normalized
CHECK(eigen_vec.GetColumn(c).IsNormalized());
// Check if matrix * eigen_vector = eigen_value * eigen_vector
Vector mat_eigvec = tensor * eigen_vec.GetColumn(c);
Vector eigval_eigvec = eigen_val[c] * eigen_vec.GetColumn(c);
CHECK(mat_eigvec.IsClose(eigval_eigvec, Square(1.0e-5f)));
}
}
}
}

98
lib/All/JoltPhysics/UnitTests/Math/HalfFloatTests.cpp Normal file
View File

@@ -0,0 +1,98 @@
// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
#include "UnitTestFramework.h"
#include <Jolt/Math/HalfFloat.h>
TEST_SUITE("HalfFloatTests")
{
#if defined(JPH_USE_F16C) || defined(JPH_USE_NEON)
TEST_CASE("TestHalfFloatToFloat")
{
// Check all half float values, 4 at a time, skip NaN's and INF
for (uint32 v = 0; v < 0x7c00; v += 2)
{
// Test value, next value and negative variants of both
UVec4 half_float(v | ((v + 1) << 16), (v | 0x8000) | (((v + 1) | 0x8000) << 16), 0, 0);
// Compare hardware intrinsic version with fallback version
Vec4 flt1 = HalfFloatConversion::ToFloat(half_float);
Vec4 flt2 = HalfFloatConversion::ToFloatFallback(half_float);
UVec4 flt1_as_int = flt1.ReinterpretAsInt();
UVec4 flt2_as_int = flt2.ReinterpretAsInt();
if (flt1_as_int != flt2_as_int)
CHECK(false); // Not using CHECK(flt1_as_int == flt2_as_int) macros as that makes the test very slow
}
}
// Helper function to compare the intrinsics version with the fallback version
static inline void CheckFloatToHalfFloat(uint32 inValue, uint32 inSign)
{
const float fvalue = BitCast<float>(inValue + inSign * 0x80000000U);
HalfFloat hf1 = HalfFloatConversion::FromFloat<HalfFloatConversion::ROUND_TO_NEAREST>(fvalue);
HalfFloat hf2 = HalfFloatConversion::FromFloatFallback<HalfFloatConversion::ROUND_TO_NEAREST>(fvalue);
bool result = (hf1 == hf2);
if (!result)
CHECK(false); // Not using CHECK(hf1 == hf2) macros as that makes the test very slow
hf1 = HalfFloatConversion::FromFloat<HalfFloatConversion::ROUND_TO_POS_INF>(fvalue);
hf2 = HalfFloatConversion::FromFloatFallback<HalfFloatConversion::ROUND_TO_POS_INF>(fvalue);
result = (hf1 == hf2);
if (!result)
CHECK(false);
hf1 = HalfFloatConversion::FromFloat<HalfFloatConversion::ROUND_TO_NEG_INF>(fvalue);
hf2 = HalfFloatConversion::FromFloatFallback<HalfFloatConversion::ROUND_TO_NEG_INF>(fvalue);
result = (hf1 == hf2);
if (!result)
CHECK(false);
}
TEST_CASE("TestFloatToHalfFloat")
{
for (uint32 sign = 0; sign < 2; ++sign)
{
// Zero and smallest possible float
for (uint32 value = 0; value < 2; value++)
CheckFloatToHalfFloat(value, sign);
// Floats that are large enough to become a denormalized half float, incrementing by smallest increment that can make a difference
for (uint32 value = (HalfFloatConversion::FLOAT_EXPONENT_BIAS - HalfFloatConversion::HALF_FLT_EXPONENT_BIAS - HalfFloatConversion::HALF_FLT_MANTISSA_BITS) << HalfFloatConversion::FLOAT_EXPONENT_POS; value < HalfFloatConversion::FLOAT_EXPONENT_MASK << HalfFloatConversion::FLOAT_EXPONENT_POS; value += 1 << (HalfFloatConversion::FLOAT_MANTISSA_BITS - HalfFloatConversion::HALF_FLT_MANTISSA_BITS - 2))
CheckFloatToHalfFloat(value, sign);
// INF
CheckFloatToHalfFloat(0x7f800000U, sign);
// Nan
CheckFloatToHalfFloat(0x7fc00000U, sign);
}
}
#endif
TEST_CASE("TestHalfFloatINF")
{
// Float -> half float
CHECK(HalfFloatConversion::FromFloatFallback<HalfFloatConversion::ROUND_TO_NEAREST>(BitCast<float>(0x7f800000U)) == HALF_FLT_INF);
CHECK(HalfFloatConversion::FromFloatFallback<HalfFloatConversion::ROUND_TO_NEAREST>(BitCast<float>(0xff800000U)) == HALF_FLT_INF_NEGATIVE);
// Half float -> float
UVec4 half_float(uint32(HALF_FLT_INF) | (uint32(HALF_FLT_INF_NEGATIVE) << 16), 0, 0, 0);
UVec4 flt = HalfFloatConversion::ToFloatFallback(half_float).ReinterpretAsInt();
CHECK(flt == UVec4(0x7f800000U, 0xff800000U, 0, 0));
}
TEST_CASE("TestHalfFloatNaN")
{
// Float -> half float
CHECK(HalfFloatConversion::FromFloatFallback<HalfFloatConversion::ROUND_TO_NEAREST>(BitCast<float>(0x7fc00000U)) == HALF_FLT_NANQ);
CHECK(HalfFloatConversion::FromFloatFallback<HalfFloatConversion::ROUND_TO_NEAREST>(BitCast<float>(0xffc00000U)) == HALF_FLT_NANQ_NEGATIVE);
// Half float -> float
UVec4 half_float(uint32(HALF_FLT_NANQ) | (uint32(HALF_FLT_NANQ_NEGATIVE) << 16), 0, 0, 0);
UVec4 flt = HalfFloatConversion::ToFloatFallback(half_float).ReinterpretAsInt();
CHECK(flt == UVec4(0x7fc00000U, 0xffc00000U, 0, 0));
}
}

570
lib/All/JoltPhysics/UnitTests/Math/Mat44Tests.cpp Normal file
View File

@@ -0,0 +1,570 @@
// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
#include "UnitTestFramework.h"
#include <Jolt/Math/Mat44.h>
#include <Jolt/Core/StringTools.h>
TEST_SUITE("Mat44Tests")
{
TEST_CASE("TestMat44Zero")
{
Mat44 zero = Mat44::sZero();
for (int row = 0; row < 4; ++row)
for (int col = 0; col < 4; ++col)
CHECK(zero(row, col) == 0.0f);
}
TEST_CASE("TestMat44Column")
{
Mat44 mat = Mat44::sZero();
mat.SetColumn4(0, Vec4(1, 2, 3, 4));
CHECK(mat.GetColumn4(0) == Vec4(1, 2, 3, 4));
mat.SetColumn3(0, Vec3(5, 6, 7));
CHECK(mat.GetColumn3(0) == Vec3(5, 6, 7));
CHECK(mat.GetColumn4(0) == Vec4(5, 6, 7, 0));
mat.SetAxisX(Vec3(8, 9, 10));
mat.SetAxisY(Vec3(11, 12, 13));
mat.SetAxisZ(Vec3(14, 15, 16));
mat.SetTranslation(Vec3(17, 18, 19));
CHECK(mat.GetAxisX() == Vec3(8, 9, 10));
CHECK(mat.GetAxisY() == Vec3(11, 12, 13));
CHECK(mat.GetAxisZ() == Vec3(14, 15, 16));
CHECK(mat.GetTranslation() == Vec3(17, 18, 19));
mat.SetDiagonal3(Vec3(20, 21, 22));
CHECK(mat.GetDiagonal3() == Vec3(20, 21, 22));
CHECK(mat.GetAxisX() == Vec3(20, 9, 10));
CHECK(mat.GetAxisY() == Vec3(11, 21, 13));
CHECK(mat.GetAxisZ() == Vec3(14, 15, 22));
mat.SetDiagonal4(Vec4(23, 24, 25, 26));
CHECK(mat.GetDiagonal4() == Vec4(23, 24, 25, 26));
CHECK(mat.GetAxisX() == Vec3(23, 9, 10));
CHECK(mat.GetAxisY() == Vec3(11, 24, 13));
CHECK(mat.GetAxisZ() == Vec3(14, 15, 25));
CHECK(mat.GetColumn4(3) == Vec4(17, 18, 19, 26));
}
TEST_CASE("TestMat44NaN")
{
Mat44 nan = Mat44::sNaN();
for (int row = 0; row < 4; ++row)
for (int col = 0; col < 4; ++col)
CHECK(isnan(nan(row, col)));
}
TEST_CASE("TestMat44Identity")
{
Mat44 identity = Mat44::sIdentity();
for (int row = 0; row < 4; ++row)
for (int col = 0; col < 4; ++col)
if (row != col)
CHECK(identity(row, col) == 0.0f);
else
CHECK(identity(row, col) == 1.0f);
}
TEST_CASE("TestMat44Construct")
{
Mat44 mat(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), Vec4(13, 14, 15, 16));
CHECK(mat(0, 0) == 1.0f);
CHECK(mat(1, 0) == 2.0f);
CHECK(mat(2, 0) == 3.0f);
CHECK(mat(3, 0) == 4.0f);
CHECK(mat(0, 1) == 5.0f);
CHECK(mat(1, 1) == 6.0f);
CHECK(mat(2, 1) == 7.0f);
CHECK(mat(3, 1) == 8.0f);
CHECK(mat(0, 2) == 9.0f);
CHECK(mat(1, 2) == 10.0f);
CHECK(mat(2, 2) == 11.0f);
CHECK(mat(3, 2) == 12.0f);
CHECK(mat(0, 3) == 13.0f);
CHECK(mat(1, 3) == 14.0f);
CHECK(mat(2, 3) == 15.0f);
CHECK(mat(3, 3) == 16.0f);
Mat44 mat2(mat);
CHECK(mat2(0, 0) == 1.0f);
CHECK(mat2(1, 0) == 2.0f);
CHECK(mat2(2, 0) == 3.0f);
CHECK(mat2(3, 0) == 4.0f);
CHECK(mat2(0, 1) == 5.0f);
CHECK(mat2(1, 1) == 6.0f);
CHECK(mat2(2, 1) == 7.0f);
CHECK(mat2(3, 1) == 8.0f);
CHECK(mat2(0, 2) == 9.0f);
CHECK(mat2(1, 2) == 10.0f);
CHECK(mat2(2, 2) == 11.0f);
CHECK(mat2(3, 2) == 12.0f);
CHECK(mat2(0, 3) == 13.0f);
CHECK(mat2(1, 3) == 14.0f);
CHECK(mat2(2, 3) == 15.0f);
CHECK(mat2(3, 3) == 16.0f);
// Check equal
CHECK(mat == mat2);
CHECK(!(mat != mat2));
// Make unequal
mat(3, 3) = 1;
// Check non-equal
CHECK(!(mat == mat2));
CHECK(mat != mat2);
}
TEST_CASE("TestMat44IsClose")
{
Mat44 mat = Mat44::sIdentity();
Mat44 mat2(mat);
CHECK(mat.IsClose(mat2, Square(0.1f)));
mat2(0, 1) = 0.09f;
CHECK(mat.IsClose(mat2, Square(0.1f)));
mat2(0, 1) = 0.11f;
CHECK(!mat.IsClose(mat2, Square(0.1f)));
}
TEST_CASE("TestMat44Translation")
{
CHECK(Mat44::sTranslation(Vec3(2, 3, 4)) == Mat44(Vec4(1, 0, 0, 0), Vec4(0, 1, 0, 0), Vec4(0, 0, 1, 0), Vec4(2, 3, 4, 1)));
}
TEST_CASE("TestMat44Scale")
{
CHECK(Mat44::sScale(2) == Mat44(Vec4(2, 0, 0, 0), Vec4(0, 2, 0, 0), Vec4(0, 0, 2, 0), Vec4(0, 0, 0, 1)));
CHECK(Mat44::sScale(Vec3(2, 3, 4)) == Mat44(Vec4(2, 0, 0, 0), Vec4(0, 3, 0, 0), Vec4(0, 0, 4, 0), Vec4(0, 0, 0, 1)));
}
TEST_CASE("TestMat44Rotation")
{
Mat44 mat(Vec4(1, 2, 3, 0), Vec4(5, 6, 7, 0), Vec4(9, 10, 11, 0), Vec4(13, 14, 15, 16));
CHECK(mat.GetRotation() == Mat44(Vec4(1, 2, 3, 0), Vec4(5, 6, 7, 0), Vec4(9, 10, 11, 0), Vec4(0, 0, 0, 1)));
}
TEST_CASE("TestMat44SetRotation")
{
Mat44 mat(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), Vec4(13, 14, 15, 16));
Mat44 mat2(Vec4(17, 18, 19, 20), Vec4(21, 22, 23, 24), Vec4(25, 26, 27, 28), Vec4(29, 30, 31, 32));
mat.SetRotation(mat2);
CHECK(mat == Mat44(Vec4(17, 18, 19, 20), Vec4(21, 22, 23, 24), Vec4(25, 26, 27, 28), Vec4(13, 14, 15, 16)));
}
TEST_CASE("TestMat44RotationSafe")
{
Mat44 mat(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), Vec4(13, 14, 15, 16));
CHECK(mat.GetRotationSafe() == Mat44(Vec4(1, 2, 3, 0), Vec4(5, 6, 7, 0), Vec4(9, 10, 11, 0), Vec4(0, 0, 0, 1)));
}
TEST_CASE("TestMat44LoadStore")
{
Mat44 mat(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), Vec4(13, 14, 15, 16));
Float4 storage[4];
mat.StoreFloat4x4(storage);
CHECK(storage[0].x == 1.0f);
CHECK(storage[0].y == 2.0f);
CHECK(storage[0].z == 3.0f);
CHECK(storage[0].w == 4.0f);
CHECK(storage[1].x == 5.0f);
CHECK(storage[1].y == 6.0f);
CHECK(storage[1].z == 7.0f);
CHECK(storage[1].w == 8.0f);
CHECK(storage[2].x == 9.0f);
CHECK(storage[2].y == 10.0f);
CHECK(storage[2].z == 11.0f);
CHECK(storage[2].w == 12.0f);
CHECK(storage[3].x == 13.0f);
CHECK(storage[3].y == 14.0f);
CHECK(storage[3].z == 15.0f);
CHECK(storage[3].w == 16.0f);
Mat44 mat2 = Mat44::sLoadFloat4x4(storage);
CHECK(mat2 == mat);
}
TEST_CASE("TestMat44LoadAligned")
{
alignas(16) float values[16] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
Mat44 mat = Mat44::sLoadFloat4x4Aligned((const Float4 *)values);
CHECK(mat == Mat44(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), Vec4(13, 14, 15, 16)));
}
TEST_CASE("TestMat44MultiplyMat44")
{
Mat44 mat(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), Vec4(13, 14, 15, 16));
Mat44 mat2(Vec4(17, 18, 19, 20), Vec4(21, 22, 23, 24), Vec4(25, 26, 27, 28), Vec4(29, 30, 31, 32));
Mat44 result = mat * mat2;
CHECK(result == Mat44(Vec4(538, 612, 686, 760), Vec4(650, 740, 830, 920), Vec4(762, 868, 974, 1080), Vec4(874, 996, 1118, 1240)));
}
TEST_CASE("TestMat44Add")
{
Mat44 mat(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), Vec4(13, 14, 15, 16));
Mat44 mat2(Vec4(17, 18, 19, 20), Vec4(21, 22, 23, 24), Vec4(25, 26, 27, 28), Vec4(29, 30, 31, 32));
Mat44 result = mat + mat2;
CHECK(result == Mat44(Vec4(18, 20, 22, 24), Vec4(26, 28, 30, 32), Vec4(34, 36, 38, 40), Vec4(42, 44, 46, 48)));
mat += mat2;
CHECK(mat == Mat44(Vec4(18, 20, 22, 24), Vec4(26, 28, 30, 32), Vec4(34, 36, 38, 40), Vec4(42, 44, 46, 48)));
}
TEST_CASE("TestMat44Sub")
{
Mat44 mat(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), Vec4(13, 14, 15, 16));
Mat44 mat2(Vec4(32, 31, 30, 29), Vec4(28, 27, 26, 25), Vec4(24, 23, 22, 21), Vec4(20, 19, 18, 17));
Mat44 result = mat - mat2;
CHECK(result == Mat44(Vec4(-31, -29, -27, -25), Vec4(-23, -21, -19, -17), Vec4(-15, -13, -11, -9), Vec4(-7, -5, -3, -1)));
}
TEST_CASE("TestMat44Negate")
{
Mat44 mat(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), Vec4(13, 14, 15, 16));
Mat44 result = -mat;
CHECK(result == Mat44(Vec4(-1, -2, -3, -4), Vec4(-5, -6, -7, -8), Vec4(-9, -10, -11, -12), Vec4(-13, -14, -15, -16)));
}
TEST_CASE("TestMat44MultiplyVec3")
{
Mat44 mat(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), Vec4(13, 14, 15, 16));
Vec3 vec(17, 18, 19);
Vec3 result = mat * vec;
CHECK(result == Vec3(291, 346, 401));
result = mat.Multiply3x3(vec);
CHECK(result == Vec3(278, 332, 386));
result = mat.Multiply3x3Transposed(vec);
CHECK(result == Vec3(110, 326, 542));
}
TEST_CASE("TestMat44MultiplyVec4")
{
Mat44 mat(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), Vec4(13, 14, 15, 16));
Vec4 vec(17, 18, 19, 20);
Vec4 result = mat * vec;
CHECK(result == Vec4(538, 612, 686, 760));
}
TEST_CASE("TestMat44Scale")
{
Mat44 mat(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), Vec4(13, 14, 15, 16));
Mat44 result = mat * 2.0f;
CHECK(result == Mat44(Vec4(2, 4, 6, 8), Vec4(10, 12, 14, 16), Vec4(18, 20, 22, 24), Vec4(26, 28, 30, 32)));
CHECK(result != mat);
result *= 0.5f;
CHECK(result == mat);
}
TEST_CASE("TestMat44Transposed")
{
Mat44 mat(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), Vec4(13, 14, 15, 16));
Mat44 result = mat.Transposed();
CHECK(result == Mat44(Vec4(1, 5, 9, 13), Vec4(2, 6, 10, 14), Vec4(3, 7, 11, 15), Vec4(4, 8, 12, 16)));
}
TEST_CASE("TestMat44Transposed3x3")
{
Mat44 mat(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), Vec4(13, 14, 15, 16));
Mat44 result = mat.Transposed3x3();
CHECK(result == Mat44(Vec4(1, 5, 9, 0), Vec4(2, 6, 10, 0), Vec4(3, 7, 11, 0), Vec4(0, 0, 0, 1)));
}
TEST_CASE("TestMat44Multiply3x3")
{
Mat44 mat1(Vec4(1, 2, 3, 0), Vec4(4, 5, 6, 0), Vec4(7, 8, 9, 0), Vec4(10, 11, 12, 1));
Mat44 mat2(Vec4(13, 14, 15, 0), Vec4(16, 17, 18, 0), Vec4(19, 20, 21, 0), Vec4(22, 23, 24, 1));
Mat44 result = mat1.Multiply3x3(mat2);
CHECK(result.GetColumn4(3) == Vec4(0, 0, 0, 1));
Mat44 result2 = mat1.GetRotationSafe() * mat2.GetRotationSafe();
CHECK(result == result2);
}
TEST_CASE("TestMat44Multiply3x3LeftTransposed")
{
Mat44 mat1(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), Vec4(13, 14, 15, 16));
Mat44 mat2(Vec4(17, 18, 19, 20), Vec4(21, 22, 23, 24), Vec4(25, 26, 27, 28), Vec4(29, 30, 31, 32));
Mat44 result = mat1.Multiply3x3LeftTransposed(mat2);
CHECK(result.GetColumn4(3) == Vec4(0, 0, 0, 1));
Mat44 result2 = mat1.GetRotationSafe().Transposed() * mat2.GetRotationSafe();
CHECK(result == result2);
}
TEST_CASE("TestMat44Multiply3x3RightTransposed")
{
Mat44 mat1(Vec4(1, 2, 3, 0), Vec4(4, 5, 6, 0), Vec4(7, 8, 9, 0), Vec4(10, 11, 12, 1));
Mat44 mat2(Vec4(13, 14, 15, 0), Vec4(16, 17, 18, 0), Vec4(19, 20, 21, 0), Vec4(22, 23, 24, 1));
Mat44 result = mat1.Multiply3x3RightTransposed(mat2);
CHECK(result.GetColumn4(3) == Vec4(0, 0, 0, 1));
Mat44 result2 = mat1.GetRotationSafe() * mat2.GetRotationSafe().Transposed();
CHECK(result == result2);
}
TEST_CASE("TestMat44Inversed")
{
Mat44 mat(Vec4(0, 2, 0, 8), Vec4(4, 0, 16, 0), Vec4(0, 16, 0, 4), Vec4(8, 0, 2, 0));
Mat44 inverse = mat.Inversed();
Mat44 identity = mat * inverse;
CHECK(identity == Mat44::sIdentity());
}
TEST_CASE("TestMat44Inversed3x3")
{
Mat44 mat(Vec4(1, 2, 0, 0), Vec4(4, 0, 8, 0), Vec4(0, 16, 0, 0), Vec4(1, 2, 3, 1));
Mat44 inverse = mat.Inversed3x3();
CHECK(inverse.GetColumn4(3) == Vec4(0, 0, 0, 1));
Mat44 identity = mat.Multiply3x3(inverse);
CHECK(identity == Mat44::sIdentity());
}
TEST_CASE("TestMat44SetInversed3x3")
{
Mat44 mat(Vec4(1, 2, 0, 0), Vec4(4, 0, 8, 0), Vec4(0, 16, 0, 0), Vec4(1, 2, 3, 1));
// First test succeeding inverse
Mat44 inverse;
CHECK(inverse.SetInversed3x3(mat));
CHECK(inverse.GetColumn4(3) == Vec4(0, 0, 0, 1));
Mat44 identity = mat.Multiply3x3(inverse);
CHECK(identity == Mat44::sIdentity());
// Now make singular
mat(0, 0) = 0.0f;
CHECK(!inverse.SetInversed3x3(mat));
}
TEST_CASE("TestMat44GetDeterminant3x3")
{
Mat44 mat(Vec4(1, 2, 0, 0), Vec4(4, 0, 8, 0), Vec4(0, 16, 0, 0), Vec4(1, 2, 3, 1));
CHECK(mat.GetDeterminant3x3() == -128);
}
TEST_CASE("TestMat44Adjointed3x3")
{
Mat44 mat(Vec4(1, 2, 3, 0), Vec4(5, 6, 7, 0), Vec4(9, 10, 11, 0), Vec4(13, 14, 15, 16));
Mat44 result = mat.Adjointed3x3();
CHECK(result == Mat44(Vec4(-4, 8, -4, 0), Vec4(8, -16, 8, 0), Vec4(-4, 8, -4, 0), Vec4(0, 0, 0, 1)));
}
TEST_CASE("TestMat44RotationXYZ")
{
Mat44 rot = Mat44::sRotationX(0.5f * JPH_PI);
Vec3 v = rot * Vec3(1, 0, 0);
CHECK(v == Vec3(1, 0, 0));
v = rot * Vec3(0, 1, 0);
CHECK_APPROX_EQUAL(v, Vec3(0, 0, 1));
v = rot * Vec3(0, 0, 1);
CHECK_APPROX_EQUAL(v, Vec3(0, -1, 0));
rot = Mat44::sRotationY(0.5f * JPH_PI);
v = rot * Vec3(1, 0, 0);
CHECK_APPROX_EQUAL(v, Vec3(0, 0, -1));
v = rot * Vec3(0, 1, 0);
CHECK(v == Vec3(0, 1, 0));
v = rot * Vec3(0, 0, 1);
CHECK_APPROX_EQUAL(v, Vec3(1, 0, 0));
rot = Mat44::sRotationZ(0.5f * JPH_PI);
v = rot * Vec3(1, 0, 0);
CHECK_APPROX_EQUAL(v, Vec3(0, 1, 0));
v = rot * Vec3(0, 1, 0);
CHECK_APPROX_EQUAL(v, Vec3(-1, 0, 0));
v = rot * Vec3(0, 0, 1);
CHECK(v == Vec3(0, 0, 1));
}
TEST_CASE("TestMat44RotationAxisAngle")
{
Mat44 r1 = Mat44::sRotationX(0.1f * JPH_PI);
Mat44 r2 = Mat44::sRotation(Vec3(1, 0, 0), 0.1f * JPH_PI);
CHECK_APPROX_EQUAL(r1, r2);
r1 = Mat44::sRotationY(0.2f * JPH_PI);
r2 = Mat44::sRotation(Vec3(0, 1, 0), 0.2f * JPH_PI);
CHECK_APPROX_EQUAL(r1, r2);
r1 = Mat44::sRotationZ(0.3f * JPH_PI);
r2 = Mat44::sRotation(Vec3(0, 0, 1), 0.3f * JPH_PI);
CHECK_APPROX_EQUAL(r1, r2);
}
TEST_CASE("TestMat44CrossProduct")
{
Vec3 v1(1, 2, 3);
Vec3 v2(4, 5, 6);
Vec3 v3 = v1.Cross(v2);
Vec3 v4 = Mat44::sCrossProduct(v1) * v2;
CHECK(v3 == v4);
}
TEST_CASE("TestMat44OuterProduct")
{
Vec3 v1(1, 2, 3);
Vec3 v2(4, 5, 6);
CHECK(Mat44::sOuterProduct(v1, v2) == Mat44(Vec4(1 * 4, 2 * 4, 3 * 4, 0), Vec4(1 * 5, 2 * 5, 3 * 5, 0), Vec4(1 * 6, 2 * 6, 3 * 6, 0), Vec4(0, 0, 0, 1)));
}
TEST_CASE("TestMat44QuatLeftMultiply")
{
Quat p(2, 3, 4, 1);
Quat q(6, 7, 8, 5);
Quat r1 = p * q;
Quat r2 = Quat(Mat44::sQuatLeftMultiply(p) * q.GetXYZW());
CHECK(r1 == r2);
}
TEST_CASE("TestMat44QuatRightMultiply")
{
Quat p(2, 3, 4, 1);
Quat q(6, 7, 8, 5);
Quat r1 = q * p;
Quat r2 = Quat(Mat44::sQuatRightMultiply(p) * q.GetXYZW());
CHECK(r1 == r2);
}
TEST_CASE("TestMat44InverseRotateTranslate")
{
Quat rot = Quat::sRotation(Vec3(0, 1, 0), 0.2f * JPH_PI);
Vec3 pos(2, 3, 4);
Mat44 m1 = Mat44::sRotationTranslation(rot, pos).Inversed();
Mat44 m2 = Mat44::sInverseRotationTranslation(rot, pos);
CHECK_APPROX_EQUAL(m1, m2);
}
TEST_CASE("TestMat44InversedRotationTranslation")
{
Quat rot = Quat::sRotation(Vec3(0, 1, 0), 0.2f * JPH_PI);
Vec3 pos(2, 3, 4);
Mat44 m1 = Mat44::sRotationTranslation(rot, pos).InversedRotationTranslation();
Mat44 m2 = Mat44::sInverseRotationTranslation(rot, pos);
CHECK_APPROX_EQUAL(m1, m2);
}
TEST_CASE("TestMat44Decompose")
{
Mat44 rotation = Mat44::sRotationX(0.1f * JPH_PI) * Mat44::sRotationZ(0.2f * JPH_PI);
Vec3 scale = Vec3(-1, 2, 3);
Mat44 mat = rotation * Mat44::sScale(scale);
CHECK(mat.GetDeterminant3x3() < 0); // Left handed
Vec3 new_scale;
Mat44 new_rotation = mat.Decompose(new_scale);
CHECK(new_rotation.GetDeterminant3x3() > 0); // Right handed
Mat44 mat2 = new_rotation * Mat44::sScale(new_scale);
CHECK(mat.IsClose(mat2));
}
TEST_CASE("TestMat44PrePostScaled")
{
Mat44 m(Vec4(2, 3, 4, 0), Vec4(5, 6, 7, 0), Vec4(8, 9, 10, 0), Vec4(11, 12, 13, 1));
Vec3 v(14, 15, 16);
CHECK(m.PreScaled(v) == m * Mat44::sScale(v));
CHECK(m.PostScaled(v) == Mat44::sScale(v) * m);
}
TEST_CASE("TestMat44PrePostTranslated")
{
Mat44 m(Vec4(2, 3, 4, 0), Vec4(5, 6, 7, 0), Vec4(8, 9, 10, 0), Vec4(11, 12, 13, 1));
Vec3 v(14, 15, 16);
CHECK(m.PreTranslated(v) == m * Mat44::sTranslation(v));
CHECK(m.PostTranslated(v) == Mat44::sTranslation(v) * m);
}
TEST_CASE("TestMat44Decompose")
{
// Create a rotation/translation matrix
Quat rot = Quat::sRotation(Vec3(1, 1, 1).Normalized(), 0.2f * JPH_PI);
Vec3 pos(2, 3, 4);
Mat44 rotation_translation = Mat44::sRotationTranslation(rot, pos);
// Scale the matrix
Vec3 scale(2, 1, 3);
Mat44 m1 = rotation_translation * Mat44::sScale(scale);
// Decompose scale
Vec3 scale_out;
Mat44 m2 = m1.Decompose(scale_out);
// Check individual components
CHECK_APPROX_EQUAL(rotation_translation, m2);
CHECK_APPROX_EQUAL(scale, scale_out);
}
TEST_CASE("TestMat44DecomposeSkewed")
{
// Create a rotation/translation matrix
Quat rot = Quat::sRotation(Vec3(1, 1, 1).Normalized(), 0.2f * JPH_PI);
Vec3 pos(2, 3, 4);
Mat44 rotation_translation = Mat44::sRotationTranslation(rot, pos);
// Skew the matrix by applying a non-uniform scale
Mat44 skewed_rotation_translation = Mat44::sScale(Vec3(1.0f, 0.99f, 0.98f)) * rotation_translation;
float val = skewed_rotation_translation.GetAxisX().Cross(skewed_rotation_translation.GetAxisY()).Dot(skewed_rotation_translation.GetAxisZ());
CHECK(abs(val - 1.0f) > 0.01f); // Check not matrix is no longer perpendicular
// Scale the matrix
Vec3 scale(2, 1, 3);
Mat44 m1 = skewed_rotation_translation * Mat44::sScale(scale);
// Decompose scale
Vec3 scale_out;
Mat44 m2 = m1.Decompose(scale_out);
// Check individual components
CHECK_APPROX_EQUAL(m2.GetAxisX(), skewed_rotation_translation.GetAxisX().Normalized()); // Check X axis didn't change
CHECK_APPROX_EQUAL(m2.GetAxisY(), skewed_rotation_translation.GetAxisY().Normalized(), 0.003f); // Y axis may move a bit
CHECK_APPROX_EQUAL(m2.GetAxisZ(), skewed_rotation_translation.GetAxisZ().Normalized(), 0.02f); // Z axis may move a bit
CHECK_APPROX_EQUAL(m2.GetAxisX().Cross(m2.GetAxisY()).Dot(m2.GetAxisZ()), 1.0f); // Check perpendicular
CHECK_APPROX_EQUAL(scale, scale_out, 0.05f); // Scale may change a bit
}
TEST_CASE("TestDMat44GetQuaternion")
{
Quat rot = Quat::sRotation(Vec3(1, 1, 1).Normalized(), 0.2f * JPH_PI);
Mat44 mat = Mat44::sRotation(rot);
CHECK_APPROX_EQUAL(mat.GetQuaternion(), rot);
}
TEST_CASE("TestDMat44ConvertToString")
{
Mat44 v(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12), Vec4(13, 14, 15, 16));
CHECK(ConvertToString(v) == "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16");
}
}

84
lib/All/JoltPhysics/UnitTests/Math/MathTests.cpp Normal file
View File

@@ -0,0 +1,84 @@
// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
#include "UnitTestFramework.h"
#include <Jolt/Math/Mat44.h>
TEST_SUITE("Mat44Tests")
{
TEST_CASE("TestCountTrailingZeros")
{
CHECK(CountTrailingZeros(0) == 32);
for (int i = 0; i < 32; ++i)
CHECK(CountTrailingZeros(1U << i) == i);
}
TEST_CASE("TestCountLeadingZeros")
{
CHECK(CountLeadingZeros(0) == 32);
for (int i = 0; i < 32; ++i)
CHECK(CountLeadingZeros(1U << i) == 31 - i);
}
TEST_CASE("TestCountBits")
{
CHECK(CountBits(0) == 0);
CHECK(CountBits(0b10000000000000000000000000000000) == 1);
CHECK(CountBits(0b00000000000000000000000000000001) == 1);
CHECK(CountBits(0b10000000000000001000000000000000) == 2);
CHECK(CountBits(0b00000000000000010000000000000001) == 2);
CHECK(CountBits(0b10000000100000001000000010000000) == 4);
CHECK(CountBits(0b00000001000000010000000100000001) == 4);
CHECK(CountBits(0b10001000100010001000100010001000) == 8);
CHECK(CountBits(0b00010001000100010001000100010001) == 8);
CHECK(CountBits(0b10101010101010101010101010101010) == 16);
CHECK(CountBits(0b01010101010101010101010101010101) == 16);
CHECK(CountBits(0b11111111111111111111111111111111) == 32);
}
TEST_CASE("TestNextPowerOf2")
{
CHECK(GetNextPowerOf2(0) == 1);
for (int i = 0; i < 31; ++i)
{
uint32 pow = uint32(1) << i;
if (pow > 2)
CHECK(GetNextPowerOf2(pow - 1) == pow);
CHECK(GetNextPowerOf2(pow) == pow);
CHECK(GetNextPowerOf2(pow + 1) == pow << 1);
}
CHECK(GetNextPowerOf2(0x8000000U - 1) == 0x8000000U);
CHECK(GetNextPowerOf2(0x8000000U) == 0x8000000U);
}
TEST_CASE("TestCenterAngleAroundZero")
{
for (int i = 0; i < 10; i += 2)
{
CHECK_APPROX_EQUAL(CenterAngleAroundZero(i * JPH_PI), 0, 1.0e-5f);
CHECK_APPROX_EQUAL(CenterAngleAroundZero((0.5f + i) * JPH_PI), 0.5f * JPH_PI, 1.0e-5f);
CHECK_APPROX_EQUAL(CenterAngleAroundZero((1.5f + i) * JPH_PI), -0.5f * JPH_PI, 1.0e-5f);
CHECK_APPROX_EQUAL(CenterAngleAroundZero(-(0.5f + i) * JPH_PI), -0.5f * JPH_PI, 1.0e-5f);
CHECK_APPROX_EQUAL(CenterAngleAroundZero(-(1.5f + i) * JPH_PI), 0.5f * JPH_PI, 1.0e-5f);
CHECK_APPROX_EQUAL(CenterAngleAroundZero(-(0.99f + i) * JPH_PI), -0.99f * JPH_PI, 1.0e-5f);
CHECK_APPROX_EQUAL(CenterAngleAroundZero((0.99f + i) * JPH_PI), 0.99f * JPH_PI, 1.0e-5f);
}
}
TEST_CASE("TestIsPowerOf2")
{
for (int i = 0; i < 63; ++i)
CHECK(IsPowerOf2(uint64(1) << 1));
CHECK(!IsPowerOf2(-2));
CHECK(!IsPowerOf2(0));
CHECK(!IsPowerOf2(3));
CHECK(!IsPowerOf2(5));
CHECK(!IsPowerOf2(15));
CHECK(!IsPowerOf2(17));
CHECK(!IsPowerOf2(65535));
CHECK(!IsPowerOf2(65537));
}
}

118
lib/All/JoltPhysics/UnitTests/Math/MatrixTests.cpp Normal file
View File

@@ -0,0 +1,118 @@
// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
#include "UnitTestFramework.h"
#include <Jolt/Math/Matrix.h>
TEST_SUITE("MatrixTests")
{
TEST_CASE("TestMatrixEquals")
{
Matrix<3, 5> m1 = Matrix<3, 5>::sZero();
Matrix<3, 5> m2 = Matrix<3, 5>::sZero();
Matrix<3, 5> m3 = Matrix<3, 5>::sIdentity();
CHECK(m1 == m2);
CHECK(!(m1 != m2));
CHECK(m1 != m3);
CHECK(!(m1 == m3));
}
TEST_CASE("TestMatrixStream")
{
Matrix<3, 5> m1 = Matrix<3, 5>::sIdentity();
std::stringstream ss;
ss << m1;
CHECK(ss.str() == "[1, 0, 0], [0, 1, 0], [0, 0, 1], [0, 0, 0], [0, 0, 0]");
}
TEST_CASE("TestMatrixZero")
{
Matrix<3, 5> m = Matrix<3, 5>::sZero();
for (uint r = 0; r < 3; ++r)
for (uint c = 0; c < 5; ++c)
CHECK(m(r, c) == 0.0f);
}
TEST_CASE("TestMatrixIdentity")
{
Matrix<3, 5> m = Matrix<3, 5>::sIdentity();
for (uint r = 0; r < 3; ++r)
for (uint c = 0; c < 5; ++c)
CHECK(m(r, c) == (r == c? 1.0f : 0.0f));
}
TEST_CASE("TestMatrixMultiply")
{
Matrix<3, 5> m1 = Matrix<3, 5>::sZero();
Matrix<5, 4> m2 = Matrix<5, 4>::sZero();
for (uint r = 0; r < 3; ++r)
for (uint c = 0; c < 5; ++c)
m1(r, c) = float(r * 5 + c + 1);
for (uint r = 0; r < 5; ++r)
for (uint c = 0; c < 4; ++c)
m2(r, c) = float(r * 4 + c + 1);
Matrix<3, 4> m3 = m1 * m2;
CHECK(m3(0, 0) == 175.0f);
CHECK(m3(1, 0) == 400.0f);
CHECK(m3(2, 0) == 625.0f);
CHECK(m3(0, 1) == 190.0f);
CHECK(m3(1, 1) == 440.0f);
CHECK(m3(2, 1) == 690.0f);
CHECK(m3(0, 2) == 205.0f);
CHECK(m3(1, 2) == 480.0f);
CHECK(m3(2, 2) == 755.0f);
CHECK(m3(0, 3) == 220.0f);
CHECK(m3(1, 3) == 520.0f);
CHECK(m3(2, 3) == 820.0f);
}
TEST_CASE("TestMatrixInversed")
{
Matrix<4, 4> mat = Matrix<4, 4>::sZero();
mat(1, 0) = 4;
mat(3, 0) = 8;
mat(0, 1) = 2;
mat(2, 1) = 16;
mat(1, 2) = 16;
mat(3, 2) = 4;
mat(0, 3) = 8;
mat(2, 3) = 2;
Matrix<4, 4> inverse;
CHECK(inverse.SetInversed(mat));
Matrix<4, 4> identity = mat * inverse;
CHECK(identity == Matrix<4, 4>::sIdentity());
// Make non-invertible
mat(1, 0) = 0;
mat(3, 0) = 0;
CHECK(!inverse.SetInversed(mat));
}
TEST_CASE("TestMatrix22Inversed")
{
// SetInverse is specialized for 2x2 matrices
Matrix<2, 2> mat;
mat(0, 0) = 1;
mat(0, 1) = 2;
mat(1, 0) = 3;
mat(1, 1) = 4;
Matrix<2, 2> inverse;
CHECK(inverse.SetInversed(mat));
Matrix<2, 2> identity = mat * inverse;
CHECK(identity == Matrix<2, 2>::sIdentity());
// Make non-invertible
mat(0, 0) = 0;
mat(1, 0) = 0;
CHECK(!inverse.SetInversed(mat));
}
}

521
lib/All/JoltPhysics/UnitTests/Math/QuatTests.cpp Normal file
View File

@@ -0,0 +1,521 @@
// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
#include "UnitTestFramework.h"
#include <Jolt/Math/Mat44.h>
#include <Jolt/Math/Quat.h>
#include <Jolt/Core/StringTools.h>
#include <random>
TEST_SUITE("QuatTests")
{
TEST_CASE("TestQuatSetXYZW")
{
Quat q(0, 0, 0, 0);
CHECK(q == Quat(0, 0, 0, 0));
q.SetX(1);
q.SetY(2);
q.SetZ(3);
q.SetW(4);
CHECK(q == Quat(1, 2, 3, 4));
q.Set(4, 3, 2, 1);
CHECK(q == Quat(4, 3, 2, 1));
}
TEST_CASE("TestQuatEqual")
{
CHECK(Quat(1, 2, 3, 4) == Quat(1, 2, 3, 4));
CHECK(Quat(1, 2, 3, 4) != Quat(0, 2, 3, 4));
CHECK(Quat(1, 2, 3, 4) != Quat(1, 0, 3, 4));
CHECK(Quat(1, 2, 3, 4) != Quat(1, 2, 0, 4));
CHECK(Quat(1, 2, 3, 4) != Quat(1, 2, 3, 0));
}
TEST_CASE("TestQuatZero")
{
Quat zero = Quat::sZero();
CHECK(zero == Quat(0, 0, 0, 0));
}
TEST_CASE("TestQuatIdentity")
{
Quat identity = Quat::sIdentity();
CHECK_APPROX_EQUAL(identity.GetX(), 0.0f);
CHECK_APPROX_EQUAL(identity.GetY(), 0.0f);
CHECK_APPROX_EQUAL(identity.GetZ(), 0.0f);
CHECK_APPROX_EQUAL(identity.GetW(), 1.0f);
}
TEST_CASE("TestQuatIsNaN")
{
CHECK(Quat(numeric_limits<float>::quiet_NaN(), 0, 0, 0).IsNaN());
CHECK(Quat(0, numeric_limits<float>::quiet_NaN(), 0, 0).IsNaN());
CHECK(Quat(0, 0, numeric_limits<float>::quiet_NaN(), 0).IsNaN());
CHECK(Quat(0, 0, 0, numeric_limits<float>::quiet_NaN()).IsNaN());
}
TEST_CASE("TestQuatOperators")
{
CHECK(-Quat(1, 2, 3, 4) == Quat(-1, -2, -3, -4));
CHECK(Quat(1, 2, 3, 4) + Quat(5, 6, 7, 8) == Quat(6, 8, 10, 12));
CHECK(Quat(5, 6, 7, 8) - Quat(4, 3, 2, 1) == Quat(1, 3, 5, 7));
CHECK(Quat(1, 2, 3, 4) * 5.0f == Quat(5, 10, 15, 20));
CHECK(5.0f * Quat(1, 2, 3, 4) == Quat(5, 10, 15, 20));
CHECK(Quat(2, 4, 6, 8) / 2.0f == Quat(1, 2, 3, 4));
Quat v(1, 2, 3, 4);
v += Quat(5, 6, 7, 8);
CHECK(v == Quat(6, 8, 10, 12));
v -= Quat(4, 3, 2, 1);
CHECK(v == Quat(2, 5, 8, 11));
v *= 2.0f;
CHECK(v == Quat(4, 10, 16, 22));
v /= 2.0f;
CHECK(v == Quat(2, 5, 8, 11));
}
TEST_CASE("TestQuatPerpendicular")
{
Quat q1(1, 2, 3, 4);
CHECK(q1.GetPerpendicular().Dot(q1) == 0.0f);
Quat q2(-5, 4, -3, 2);
CHECK(q2.GetPerpendicular().Dot(q2) == 0.0f);
}
TEST_CASE("TestQuatNormalized")
{
CHECK(Quat(1, 0, 0, 0).IsNormalized());
CHECK(Quat(-0.7071067f, 0.7071067f, 0, 0).IsNormalized());
CHECK(Quat(0.5773502f, -0.5773502f, 0.5773502f, 0).IsNormalized());
CHECK(Quat(0.5f, -0.5f, 0.5f, -0.5f).IsNormalized());
CHECK(!Quat(2, 0, 0, 0).IsNormalized());
CHECK(!Quat(0, 2, 0, 0).IsNormalized());
CHECK(!Quat(0, 0, 2, 0).IsNormalized());
CHECK(!Quat(0, 0, 0, 2).IsNormalized());
}
TEST_CASE("TestQuatConvertMatrix")
{
UnitTestRandom random;
uniform_real_distribution<float> zero_to_two_pi(0.0f, 2.0f * JPH_PI);
for (int i = 0; i < 1000; ++i)
{
Vec3 axis = Vec3::sRandom(random);
float angle = zero_to_two_pi(random);
Mat44 m1 = Mat44::sRotation(axis, angle);
Quat q1 = m1.GetQuaternion();
Quat q2 = Quat::sRotation(axis, angle);
CHECK_APPROX_EQUAL(q1, q2);
Mat44 m2 = Mat44::sRotation(q2);
CHECK_APPROX_EQUAL(m1, m2);
}
}
TEST_CASE("TestQuatMultiplyVec3")
{
UnitTestRandom random;
uniform_real_distribution<float> zero_to_two_pi(0.0f, 2.0f * JPH_PI);
for (int i = 0; i < 1000; ++i)
{
Vec3 axis = Vec3::sRandom(random);
float angle = zero_to_two_pi(random);
Mat44 m1 = Mat44::sRotation(axis, angle);
Quat q1 = Quat::sRotation(axis, angle);
Vec3 rv = 10.0f * Vec3::sRandom(random);
Vec3 r1 = m1 * rv;
Vec3 r2 = q1 * rv;
CHECK_APPROX_EQUAL(r1, r2, 1.0e-5f);
Vec3 r3 = q1.InverseRotate(r2);
CHECK_APPROX_EQUAL(r3, rv, 1.0e-5f);
}
}
TEST_CASE("TestQuatRotateAxisXYZ")
{
UnitTestRandom random;
uniform_real_distribution<float> zero_to_two_pi(0.0f, 2.0f * JPH_PI);
for (int i = 0; i < 1000; ++i)
{
Vec3 axis = Vec3::sRandom(random);
float angle = zero_to_two_pi(random);
Quat q1 = Quat::sRotation(axis, angle);
Vec3 r1 = q1 * Vec3::sAxisX();
Vec3 r2 = q1.RotateAxisX();
CHECK_APPROX_EQUAL(r1, r2, 1.0e-5f);
r1 = q1 * Vec3::sAxisY();
r2 = q1.RotateAxisY();
CHECK_APPROX_EQUAL(r1, r2, 1.0e-5f);
r1 = q1 * Vec3::sAxisZ();
r2 = q1.RotateAxisZ();
CHECK_APPROX_EQUAL(r1, r2, 1.0e-5f);
}
}
TEST_CASE("TestQuatMultiplyQuat")
{
{
// We use a right handed system, so test that: i * j = k
Quat r1 = Quat(1, 0, 0, 0) * Quat(0, 1, 0, 0);
Quat r2 = Quat(0, 0, 1, 0);
CHECK(r1.IsClose(r2));
}
{
// Test: j * i = -k
Quat r1 = Quat(0, 1, 0, 0) * Quat(1, 0, 0, 0);
Quat r2 = Quat(0, 0, -1, 0);
CHECK(r1.IsClose(r2));
}
{
// Test predefined multiplication
Quat r1 = Quat(2, 3, 4, 1) * Quat(6, 7, 8, 5);
Quat r2 = Quat(12, 30, 24, -60);
CHECK(r1.IsClose(r2));
}
// Compare random matrix multiplications with quaternion multiplications
UnitTestRandom random;
uniform_real_distribution<float> zero_to_two_pi(0.0f, 2.0f * JPH_PI);
for (int i = 0; i < 1000; ++i)
{
Vec3 axis1 = Vec3::sRandom(random);
float angle1 = zero_to_two_pi(random);
Quat q1 = Quat::sRotation(axis1, angle1);
Mat44 m1 = Mat44::sRotation(axis1, angle1);
Vec3 axis2 = Vec3::sRandom(random);
float angle2 = zero_to_two_pi(random);
Quat q2 = Quat::sRotation(axis2, angle2);
Mat44 m2 = Mat44::sRotation(axis2, angle2);
Quat r1 = q1 * q2;
Quat r2 = (m1 * m2).GetQuaternion();
CHECK_APPROX_EQUAL(r1, r2);
}
}
TEST_CASE("TestQuatRotationAxisAngle")
{
Mat44 r1 = Mat44::sRotation(Vec3(1, 0, 0), 0.1f * JPH_PI);
Mat44 r2 = Mat44::sRotation(Quat::sRotation(Vec3(1, 0, 0), 0.1f * JPH_PI));
CHECK_APPROX_EQUAL(r1, r2);
r1 = Mat44::sRotation(Vec3(0, 1, 0), 0.2f * JPH_PI);
r2 = Mat44::sRotation(Quat::sRotation(Vec3(0, 1, 0), 0.2f * JPH_PI));
CHECK_APPROX_EQUAL(r1, r2);
r1 = Mat44::sRotation(Vec3(0, 0, 1), 0.3f * JPH_PI);
r2 = Mat44::sRotation(Quat::sRotation(Vec3(0, 0, 1), 0.3f * JPH_PI));
CHECK_APPROX_EQUAL(r1, r2);
}
TEST_CASE("TestQuatGetAxisAngle")
{
// Test identity rotation
{
Vec3 axis;
float angle;
Quat::sIdentity().GetAxisAngle(axis, angle);
CHECK_APPROX_EQUAL(Vec3::sZero(), axis);
CHECK_APPROX_EQUAL(0.0f, angle);
}
{
Vec3 axis;
float angle;
(-Quat::sIdentity()).GetAxisAngle(axis, angle);
CHECK_APPROX_EQUAL(Vec3::sZero(), axis);
CHECK_APPROX_EQUAL(0.0f, angle);
}
// Test positive rotation
Quat q1 = Quat::sRotation(Vec3(0, 1, 0), 0.2f * JPH_PI);
{
Vec3 axis;
float angle;
q1.GetAxisAngle(axis, angle);
CHECK_APPROX_EQUAL(Vec3(0, 1, 0), axis);
CHECK_APPROX_EQUAL(0.2f * JPH_PI, angle, 1.0e-5f);
}
{
Vec3 axis;
float angle;
(-q1).GetAxisAngle(axis, angle);
CHECK_APPROX_EQUAL(Vec3(0, 1, 0), axis);
CHECK_APPROX_EQUAL(0.2f * JPH_PI, angle, 1.0e-5f);
}
// Test negative rotation
Quat q2 = Quat::sRotation(Vec3(0, 1, 0), -0.2f * JPH_PI);
{
Vec3 axis;
float angle;
q2.GetAxisAngle(axis, angle);
CHECK_APPROX_EQUAL(Vec3(0, -1, 0), axis);
CHECK_APPROX_EQUAL(0.2f * JPH_PI, angle, 1.0e-5f);
}
{
Vec3 axis;
float angle;
(-q2).GetAxisAngle(axis, angle);
CHECK_APPROX_EQUAL(Vec3(0, -1, 0), axis);
CHECK_APPROX_EQUAL(0.2f * JPH_PI, angle, 1.0e-5f);
}
// Test keeping range between [0, PI]
Quat q3 = Quat::sRotation(Vec3(0, 1, 0), 1.1f * JPH_PI);
{
Vec3 axis;
float angle;
q3.GetAxisAngle(axis, angle);
CHECK_APPROX_EQUAL(Vec3(0, -1, 0), axis);
CHECK_APPROX_EQUAL(0.9f * JPH_PI, angle, 1.0e-5f);
}
{
Vec3 axis;
float angle;
(-q3).GetAxisAngle(axis, angle);
CHECK_APPROX_EQUAL(Vec3(0, -1, 0), axis);
CHECK_APPROX_EQUAL(0.9f * JPH_PI, angle, 1.0e-5f);
}
}
TEST_CASE("TestQuatInverse")
{
UnitTestRandom random;
uniform_real_distribution<float> zero_to_two_pi(0.0f, 2.0f * JPH_PI);
for (int i = 0; i < 1000; ++i)
{
Vec3 axis = Vec3::sRandom(random);
float angle = zero_to_two_pi(random);
Quat q1 = Quat::sRotation(axis, angle);
Quat q2 = q1.Inversed();
CHECK_APPROX_EQUAL(Quat::sIdentity(), q1 * q2);
}
}
TEST_CASE("TestQuatConjugate")
{
CHECK(Quat(1, 2, 3, 4).Conjugated() == Quat(-1, -2, -3, 4));
CHECK(Quat(-1, -2, -3, -4).Conjugated() == Quat(1, 2, 3, -4));
}
TEST_CASE("TestQuatEnsureWPositive")
{
CHECK(Quat(1, -2, 3, -4).EnsureWPositive() == Quat(-1, 2, -3, 4));
CHECK(Quat(-4, 5, -6, 7).EnsureWPositive() == Quat(-4, 5, -6, 7));
CHECK(Quat(1, 2, 3, 0).EnsureWPositive() == Quat(1, 2, 3, 0));
}
TEST_CASE("TestQuatStoreFloat3")
{
Float3 q1;
Quat(0.7071067f, 0, 0, -0.7071067f).StoreFloat3(&q1);
CHECK(q1 == Float3(-0.7071067f, 0, 0));
Float3 q2;
Quat(0, 0.7071067f, 0, 0.7071067f).StoreFloat3(&q2);
CHECK(q2 == Float3(0, 0.7071067f, 0));
Float3 q3;
Quat(0, 0, 1, 0).StoreFloat3(&q3);
CHECK(q3 == Float3(0, 0, 1));
}
TEST_CASE("TestQuatGetTwistAxis")
{
Quat q1 = Quat::sRotation(Vec3::sAxisX(), DegreesToRadians(-10.0f));
Quat q2 = Quat::sRotation(Vec3::sAxisY(), DegreesToRadians(20.0f));
Quat q = q1 * q2;
Quat twist1 = q.GetTwist(Vec3::sAxisX());
CHECK_APPROX_EQUAL(twist1, q1);
Quat swing1 = twist1.Inversed() * q;
CHECK_APPROX_EQUAL(swing1, q2);
Quat twist2 = swing1.GetTwist(Vec3::sAxisY());
CHECK_APPROX_EQUAL(twist2, q2);
Quat swing2 = twist2.Inversed() * swing1;
CHECK_APPROX_EQUAL(swing2, Quat::sIdentity());
CHECK(Quat::sZero().GetTwist(Vec3::sAxisX()) == Quat::sIdentity());
}
TEST_CASE("TestQuatGetRotationAngle")
{
Quat q1 = Quat::sRotation(Vec3::sAxisX(), DegreesToRadians(-10.0f));
Quat q2 = Quat::sRotation(Vec3::sAxisY(), DegreesToRadians(20.0f));
Quat q3 = Quat::sRotation(Vec3::sAxisZ(), DegreesToRadians(-95.0f));
float a = q1.GetRotationAngle(Vec3::sAxisX());
CHECK_APPROX_EQUAL(a, DegreesToRadians(-10.0f), 1.0e-5f);
a = q2.GetRotationAngle(Vec3::sAxisY());
CHECK_APPROX_EQUAL(a, DegreesToRadians(20.0f), 1.0e-5f);
a = q3.GetRotationAngle(Vec3::sAxisZ());
CHECK_APPROX_EQUAL(a, DegreesToRadians(-95.0f), 1.0e-5f);
a = (q1 * q2).GetRotationAngle(Vec3::sAxisX());
CHECK_APPROX_EQUAL(a, DegreesToRadians(-10.0f), 1.0e-5f);
a = (q3 * q1).GetRotationAngle(Vec3::sAxisX());
CHECK_APPROX_EQUAL(a, DegreesToRadians(-10.0f), 1.0e-5f);
}
TEST_CASE("TestQuatGetEulerAngles")
{
Vec3 input(DegreesToRadians(-10.0f), DegreesToRadians(20.0f), DegreesToRadians(-95.0f));
Quat qx = Quat::sRotation(Vec3::sAxisX(), input.GetX());
Quat qy = Quat::sRotation(Vec3::sAxisY(), input.GetY());
Quat qz = Quat::sRotation(Vec3::sAxisZ(), input.GetZ());
Quat q = qz * qy * qx;
Quat q2 = Quat::sEulerAngles(input);
CHECK_APPROX_EQUAL(q, q2);
Vec3 angles = q2.GetEulerAngles();
CHECK_APPROX_EQUAL(angles, input);
}
TEST_CASE("TestQuatRotationFromTo")
{
{
// Parallel vectors
Vec3 v1(10, 0, 0);
Vec3 v2(20, 0, 0);
Quat q = Quat::sFromTo(v1, v2);
CHECK_APPROX_EQUAL(q, Quat::sIdentity());
}
{
// Perpendicular vectors
Vec3 v1(10, 0, 0);
Vec3 v2(0, 20, 0);
Quat q = Quat::sFromTo(v1, v2);
CHECK_APPROX_EQUAL(v2.Normalized(), (q * v1).Normalized());
}
{
// Vectors with 180 degree angle
Vec3 v1(10, 0, 0);
Vec3 v2(-20, 0, 0);
Quat q = Quat::sFromTo(v1, v2);
CHECK_APPROX_EQUAL(v2.Normalized(), (q * v1).Normalized());
}
{
// Test v1 zero
Vec3 v1 = Vec3::sZero();
Vec3 v2(10, 0, 0);
Quat q = Quat::sFromTo(v1, v2);
CHECK(q == Quat::sIdentity());
}
{
// Test v2 zero
Vec3 v1(10, 0, 0);
Vec3 v2 = Vec3::sZero();
Quat q = Quat::sFromTo(v1, v2);
CHECK(q == Quat::sIdentity());
}
{
// Length of a vector is squared inside the function: try with sqrt(FLT_MIN) to see if that still returns a valid rotation
Vec3 v1(0, sqrt(FLT_MIN), 0);
Vec3 v2(1, 0, 0);
Quat q = Quat::sFromTo(v1, v2);
CHECK_APPROX_EQUAL(v2.Normalized(), (q * v1).Normalized());
}
}
TEST_CASE("TestQuatRotationFromToRandom")
{
UnitTestRandom random;
uniform_real_distribution<float> one_to_ten(1.0f, 10.0f);
for (int i = 0; i < 1000; ++i)
{
Vec3 v1 = one_to_ten(random) * Vec3::sRandom(random);
Vec3 v2 = one_to_ten(random) * Vec3::sRandom(random);
Quat q = Quat::sFromTo(v1, v2);
Vec3 v1t = (q * v1).Normalized();
Vec3 v2t = v2.Normalized();
CHECK_APPROX_EQUAL(v2t, v1t, 1.0e-5f);
}
}
TEST_CASE("TestQuatConvertToString")
{
Quat v(1, 2, 3, 4);
CHECK(ConvertToString(v) == "1, 2, 3, 4");
}
TEST_CASE("TestQuatLERP")
{
Quat v1(1, 2, 3, 4);
Quat v2(5, 6, 7, 8);
CHECK(v1.LERP(v2, 0.25f) == Quat(2, 3, 4, 5));
}
TEST_CASE("TestQuatSLERP")
{
Quat v1 = Quat::sIdentity();
Quat v2 = Quat::sRotation(Vec3::sAxisX(), 0.99f * JPH_PI);
CHECK_APPROX_EQUAL(v1.SLERP(v2, 0.25f), Quat::sRotation(Vec3::sAxisX(), 0.25f * 0.99f * JPH_PI));
// Check that we ignore the sign
Quat v3 = Quat(1, 2, 3, 4).Normalized();
CHECK_APPROX_EQUAL(v3.SLERP(-v3, 0.5f), v3);
}
TEST_CASE("TestQuatMultiplyImaginary")
{
UnitTestRandom random;
for (int i = 0; i < 1000; ++i)
{
Vec3 imaginary = Vec3::sRandom(random);
Quat quat = Quat::sRandom(random);
Quat r1 = Quat::sMultiplyImaginary(imaginary, quat);
Quat r2 = Quat(Vec4(imaginary, 0)) * quat;
CHECK_APPROX_EQUAL(r1, r2);
}
}
TEST_CASE("TestQuatCompressUnitQuat")
{
UnitTestRandom random;
for (int i = 0; i < 1000; ++i)
{
Quat quat = Quat::sRandom(random);
uint32 compressed = quat.CompressUnitQuat();
Quat decompressed = Quat::sDecompressUnitQuat(compressed);
Vec3 axis;
float angle;
(quat * decompressed.Conjugated()).GetAxisAngle(axis, angle);
CHECK(abs(angle) < 0.009f);
}
}
}

27
lib/All/JoltPhysics/UnitTests/Math/TrigonometryTests.cpp Normal file
View File

@@ -0,0 +1,27 @@
// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2024 Jorrit Rouwe
// SPDX-License-Identifier: MIT
#include "UnitTestFramework.h"
#include <Jolt/Math/Trigonometry.h>
TEST_SUITE("TrigonometryTests")
{
TEST_CASE("TestACosApproximate")
{
// Check error over entire range [-1, 1]
for (int i = -1000; i <= 1000; i++)
{
float x = float(i) / 1000.0f;
float acos1 = acos(x);
float acos2 = ACosApproximate(x);
CHECK_APPROX_EQUAL(acos1, acos2, 4.3e-3f);
}
// Check edge cases for exact matches
CHECK(ACosApproximate(1.0f) == 0.0f);
CHECK(ACosApproximate(1.0e-12f) == JPH_PI / 2);
CHECK(ACosApproximate(-1.0e-12f) == JPH_PI / 2);
CHECK(ACosApproximate(-1.0f) == JPH_PI);
}
}

574
lib/All/JoltPhysics/UnitTests/Math/UVec4Tests.cpp Normal file
View File

@@ -0,0 +1,574 @@
// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
#include "UnitTestFramework.h"
#include <Jolt/Core/StringTools.h>
TEST_SUITE("UVec4Tests")
{
TEST_CASE("TestUVec4Construct")
{
UVec4 v(1, 2, 3, 4);
CHECK(v.GetX() == 1);
CHECK(v.GetY() == 2);
CHECK(v.GetZ() == 3);
CHECK(v.GetW() == 4);
CHECK(v[0] == 1);
CHECK(v[1] == 2);
CHECK(v[2] == 3);
CHECK(v[3] == 4);
// Test == and != operators
CHECK(v == UVec4(1, 2, 3, 4));
CHECK(v != UVec4(1, 2, 4, 3));
}
TEST_CASE("TestUVec4Components")
{
UVec4 v(1, 2, 3, 4);
v.SetX(5);
v.SetY(6);
v.SetZ(7);
v.SetW(8);
CHECK(v == UVec4(5, 6, 7, 8));
}
TEST_CASE("TestUVec4LoadStoreInt4")
{
alignas(16) uint32 i4[] = { 1, 2, 3, 4 };
CHECK(UVec4::sLoadInt(i4) == UVec4(1, 0, 0, 0));
CHECK(UVec4::sLoadInt4(i4) == UVec4(1, 2, 3, 4));
CHECK(UVec4::sLoadInt4Aligned(i4) == UVec4(1, 2, 3, 4));
uint32 i4_out1[4];
UVec4(1, 2, 3, 4).StoreInt4(i4_out1);
CHECK(i4_out1[0] == 1);
CHECK(i4_out1[1] == 2);
CHECK(i4_out1[2] == 3);
CHECK(i4_out1[3] == 4);
alignas(16) uint32 i4_out2[4];
UVec4(1, 2, 3, 4).StoreInt4Aligned(i4_out2);
CHECK(i4_out2[0] == 1);
CHECK(i4_out2[1] == 2);
CHECK(i4_out2[2] == 3);
CHECK(i4_out2[3] == 4);
uint32 si[] = { 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 4, 0 };
CHECK(UVec4::sGatherInt4<2 * sizeof(uint32)>(si, UVec4(1, 3, 8, 9)) == UVec4(1, 2, 3, 4));
}
TEST_CASE("TestUVec4Zero")
{
UVec4 v = UVec4::sZero();
CHECK(v.GetX() == 0);
CHECK(v.GetY() == 0);
CHECK(v.GetZ() == 0);
CHECK(v.GetW() == 0);
}
TEST_CASE("TestUVec4Replicate")
{
CHECK(UVec4::sReplicate(2) == UVec4(2, 2, 2, 2));
}
TEST_CASE("TestUVec4MinMax")
{
UVec4 v1(1, 6, 3, 8);
UVec4 v2(5, 2, 7, 4);
CHECK(UVec4::sMin(v1, v2) == UVec4(1, 2, 3, 4));
CHECK(UVec4::sMax(v1, v2) == UVec4(5, 6, 7, 8));
}
TEST_CASE("TestUVec4Comparisons")
{
CHECK(UVec4::sEquals(UVec4(1, 2, 3, 4), UVec4(2, 1, 3, 4)) == UVec4(0, 0, 0xffffffffU, 0xffffffffU));
CHECK(UVec4(0x00000000U, 0x00000000U, 0x00000000U, 0x00000000U).GetTrues() == 0b0000);
CHECK(UVec4(0xffffffffU, 0x00000000U, 0x00000000U, 0x00000000U).GetTrues() == 0b0001);
CHECK(UVec4(0x00000000U, 0xffffffffU, 0x00000000U, 0x00000000U).GetTrues() == 0b0010);
CHECK(UVec4(0xffffffffU, 0xffffffffU, 0x00000000U, 0x00000000U).GetTrues() == 0b0011);
CHECK(UVec4(0x00000000U, 0x00000000U, 0xffffffffU, 0x00000000U).GetTrues() == 0b0100);
CHECK(UVec4(0xffffffffU, 0x00000000U, 0xffffffffU, 0x00000000U).GetTrues() == 0b0101);
CHECK(UVec4(0x00000000U, 0xffffffffU, 0xffffffffU, 0x00000000U).GetTrues() == 0b0110);
CHECK(UVec4(0xffffffffU, 0xffffffffU, 0xffffffffU, 0x00000000U).GetTrues() == 0b0111);
CHECK(UVec4(0x00000000U, 0x00000000U, 0x00000000U, 0xffffffffU).GetTrues() == 0b1000);
CHECK(UVec4(0xffffffffU, 0x00000000U, 0x00000000U, 0xffffffffU).GetTrues() == 0b1001);
CHECK(UVec4(0x00000000U, 0xffffffffU, 0x00000000U, 0xffffffffU).GetTrues() == 0b1010);
CHECK(UVec4(0xffffffffU, 0xffffffffU, 0x00000000U, 0xffffffffU).GetTrues() == 0b1011);
CHECK(UVec4(0x00000000U, 0x00000000U, 0xffffffffU, 0xffffffffU).GetTrues() == 0b1100);
CHECK(UVec4(0xffffffffU, 0x00000000U, 0xffffffffU, 0xffffffffU).GetTrues() == 0b1101);
CHECK(UVec4(0x00000000U, 0xffffffffU, 0xffffffffU, 0xffffffffU).GetTrues() == 0b1110);
CHECK(UVec4(0xffffffffU, 0xffffffffU, 0xffffffffU, 0xffffffffU).GetTrues() == 0b1111);
CHECK(UVec4(0x00000000U, 0x00000000U, 0x00000000U, 0x00000000U).CountTrues() == 0);
CHECK(UVec4(0xffffffffU, 0x00000000U, 0x00000000U, 0x00000000U).CountTrues() == 1);
CHECK(UVec4(0x00000000U, 0xffffffffU, 0x00000000U, 0x00000000U).CountTrues() == 1);
CHECK(UVec4(0xffffffffU, 0xffffffffU, 0x00000000U, 0x00000000U).CountTrues() == 2);
CHECK(UVec4(0x00000000U, 0x00000000U, 0xffffffffU, 0x00000000U).CountTrues() == 1);
CHECK(UVec4(0xffffffffU, 0x00000000U, 0xffffffffU, 0x00000000U).CountTrues() == 2);
CHECK(UVec4(0x00000000U, 0xffffffffU, 0xffffffffU, 0x00000000U).CountTrues() == 2);
CHECK(UVec4(0xffffffffU, 0xffffffffU, 0xffffffffU, 0x00000000U).CountTrues() == 3);
CHECK(UVec4(0x00000000U, 0x00000000U, 0x00000000U, 0xffffffffU).CountTrues() == 1);
CHECK(UVec4(0xffffffffU, 0x00000000U, 0x00000000U, 0xffffffffU).CountTrues() == 2);
CHECK(UVec4(0x00000000U, 0xffffffffU, 0x00000000U, 0xffffffffU).CountTrues() == 2);
CHECK(UVec4(0xffffffffU, 0xffffffffU, 0x00000000U, 0xffffffffU).CountTrues() == 3);
CHECK(UVec4(0x00000000U, 0x00000000U, 0xffffffffU, 0xffffffffU).CountTrues() == 2);
CHECK(UVec4(0xffffffffU, 0x00000000U, 0xffffffffU, 0xffffffffU).CountTrues() == 3);
CHECK(UVec4(0x00000000U, 0xffffffffU, 0xffffffffU, 0xffffffffU).CountTrues() == 3);
CHECK(UVec4(0xffffffffU, 0xffffffffU, 0xffffffffU, 0xffffffffU).CountTrues() == 4);
CHECK(!UVec4(0x00000000U, 0x00000000U, 0x00000000U, 0x00000000U).TestAllTrue());
CHECK(!UVec4(0xffffffffU, 0x00000000U, 0x00000000U, 0x00000000U).TestAllTrue());
CHECK(!UVec4(0x00000000U, 0xffffffffU, 0x00000000U, 0x00000000U).TestAllTrue());
CHECK(!UVec4(0xffffffffU, 0xffffffffU, 0x00000000U, 0x00000000U).TestAllTrue());
CHECK(!UVec4(0x00000000U, 0x00000000U, 0xffffffffU, 0x00000000U).TestAllTrue());
CHECK(!UVec4(0xffffffffU, 0x00000000U, 0xffffffffU, 0x00000000U).TestAllTrue());
CHECK(!UVec4(0x00000000U, 0xffffffffU, 0xffffffffU, 0x00000000U).TestAllTrue());
CHECK(!UVec4(0xffffffffU, 0xffffffffU, 0xffffffffU, 0x00000000U).TestAllTrue());
CHECK(!UVec4(0x00000000U, 0x00000000U, 0x00000000U, 0xffffffffU).TestAllTrue());
CHECK(!UVec4(0xffffffffU, 0x00000000U, 0x00000000U, 0xffffffffU).TestAllTrue());
CHECK(!UVec4(0x00000000U, 0xffffffffU, 0x00000000U, 0xffffffffU).TestAllTrue());
CHECK(!UVec4(0xffffffffU, 0xffffffffU, 0x00000000U, 0xffffffffU).TestAllTrue());
CHECK(!UVec4(0x00000000U, 0x00000000U, 0xffffffffU, 0xffffffffU).TestAllTrue());
CHECK(!UVec4(0xffffffffU, 0x00000000U, 0xffffffffU, 0xffffffffU).TestAllTrue());
CHECK(!UVec4(0x00000000U, 0xffffffffU, 0xffffffffU, 0xffffffffU).TestAllTrue());
CHECK(UVec4(0xffffffffU, 0xffffffffU, 0xffffffffU, 0xffffffffU).TestAllTrue());
CHECK(!UVec4(0x00000000U, 0x00000000U, 0x00000000U, 0x00000000U).TestAllXYZTrue());
CHECK(!UVec4(0xffffffffU, 0x00000000U, 0x00000000U, 0x00000000U).TestAllXYZTrue());
CHECK(!UVec4(0x00000000U, 0xffffffffU, 0x00000000U, 0x00000000U).TestAllXYZTrue());
CHECK(!UVec4(0xffffffffU, 0xffffffffU, 0x00000000U, 0x00000000U).TestAllXYZTrue());
CHECK(!UVec4(0x00000000U, 0x00000000U, 0xffffffffU, 0x00000000U).TestAllXYZTrue());
CHECK(!UVec4(0xffffffffU, 0x00000000U, 0xffffffffU, 0x00000000U).TestAllXYZTrue());
CHECK(!UVec4(0x00000000U, 0xffffffffU, 0xffffffffU, 0x00000000U).TestAllXYZTrue());
CHECK(UVec4(0xffffffffU, 0xffffffffU, 0xffffffffU, 0x00000000U).TestAllXYZTrue());
CHECK(!UVec4(0x00000000U, 0x00000000U, 0x00000000U, 0xffffffffU).TestAllXYZTrue());
CHECK(!UVec4(0xffffffffU, 0x00000000U, 0x00000000U, 0xffffffffU).TestAllXYZTrue());
CHECK(!UVec4(0x00000000U, 0xffffffffU, 0x00000000U, 0xffffffffU).TestAllXYZTrue());
CHECK(!UVec4(0xffffffffU, 0xffffffffU, 0x00000000U, 0xffffffffU).TestAllXYZTrue());
CHECK(!UVec4(0x00000000U, 0x00000000U, 0xffffffffU, 0xffffffffU).TestAllXYZTrue());
CHECK(!UVec4(0xffffffffU, 0x00000000U, 0xffffffffU, 0xffffffffU).TestAllXYZTrue());
CHECK(!UVec4(0x00000000U, 0xffffffffU, 0xffffffffU, 0xffffffffU).TestAllXYZTrue());
CHECK(UVec4(0xffffffffU, 0xffffffffU, 0xffffffffU, 0xffffffffU).TestAllXYZTrue());
CHECK(!UVec4(0x00000000U, 0x00000000U, 0x00000000U, 0x00000000U).TestAnyTrue());
CHECK(UVec4(0xffffffffU, 0x00000000U, 0x00000000U, 0x00000000U).TestAnyTrue());
CHECK(UVec4(0x00000000U, 0xffffffffU, 0x00000000U, 0x00000000U).TestAnyTrue());
CHECK(UVec4(0xffffffffU, 0xffffffffU, 0x00000000U, 0x00000000U).TestAnyTrue());
CHECK(UVec4(0x00000000U, 0x00000000U, 0xffffffffU, 0x00000000U).TestAnyTrue());
CHECK(UVec4(0xffffffffU, 0x00000000U, 0xffffffffU, 0x00000000U).TestAnyTrue());
CHECK(UVec4(0x00000000U, 0xffffffffU, 0xffffffffU, 0x00000000U).TestAnyTrue());
CHECK(UVec4(0xffffffffU, 0xffffffffU, 0xffffffffU, 0x00000000U).TestAnyTrue());
CHECK(UVec4(0x00000000U, 0x00000000U, 0x00000000U, 0xffffffffU).TestAnyTrue());
CHECK(UVec4(0xffffffffU, 0x00000000U, 0x00000000U, 0xffffffffU).TestAnyTrue());
CHECK(UVec4(0x00000000U, 0xffffffffU, 0x00000000U, 0xffffffffU).TestAnyTrue());
CHECK(UVec4(0xffffffffU, 0xffffffffU, 0x00000000U, 0xffffffffU).TestAnyTrue());
CHECK(UVec4(0x00000000U, 0x00000000U, 0xffffffffU, 0xffffffffU).TestAnyTrue());
CHECK(UVec4(0xffffffffU, 0x00000000U, 0xffffffffU, 0xffffffffU).TestAnyTrue());
CHECK(UVec4(0x00000000U, 0xffffffffU, 0xffffffffU, 0xffffffffU).TestAnyTrue());
CHECK(UVec4(0xffffffffU, 0xffffffffU, 0xffffffffU, 0xffffffffU).TestAnyTrue());
CHECK(!UVec4(0x00000000U, 0x00000000U, 0x00000000U, 0x00000000U).TestAnyXYZTrue());
CHECK(UVec4(0xffffffffU, 0x00000000U, 0x00000000U, 0x00000000U).TestAnyXYZTrue());
CHECK(UVec4(0x00000000U, 0xffffffffU, 0x00000000U, 0x00000000U).TestAnyXYZTrue());
CHECK(UVec4(0xffffffffU, 0xffffffffU, 0x00000000U, 0x00000000U).TestAnyXYZTrue());
CHECK(UVec4(0x00000000U, 0x00000000U, 0xffffffffU, 0x00000000U).TestAnyXYZTrue());
CHECK(UVec4(0xffffffffU, 0x00000000U, 0xffffffffU, 0x00000000U).TestAnyXYZTrue());
CHECK(UVec4(0x00000000U, 0xffffffffU, 0xffffffffU, 0x00000000U).TestAnyXYZTrue());
CHECK(UVec4(0xffffffffU, 0xffffffffU, 0xffffffffU, 0x00000000U).TestAnyXYZTrue());
CHECK(!UVec4(0x00000000U, 0x00000000U, 0x00000000U, 0xffffffffU).TestAnyXYZTrue());
CHECK(UVec4(0xffffffffU, 0x00000000U, 0x00000000U, 0xffffffffU).TestAnyXYZTrue());
CHECK(UVec4(0x00000000U, 0xffffffffU, 0x00000000U, 0xffffffffU).TestAnyXYZTrue());
CHECK(UVec4(0xffffffffU, 0xffffffffU, 0x00000000U, 0xffffffffU).TestAnyXYZTrue());
CHECK(UVec4(0x00000000U, 0x00000000U, 0xffffffffU, 0xffffffffU).TestAnyXYZTrue());
CHECK(UVec4(0xffffffffU, 0x00000000U, 0xffffffffU, 0xffffffffU).TestAnyXYZTrue());
CHECK(UVec4(0x00000000U, 0xffffffffU, 0xffffffffU, 0xffffffffU).TestAnyXYZTrue());
CHECK(UVec4(0xffffffffU, 0xffffffffU, 0xffffffffU, 0xffffffffU).TestAnyXYZTrue());
}
TEST_CASE("TestUVec4Select")
{
CHECK(UVec4::sSelect(UVec4(1, 2, 3, 4), UVec4(5, 6, 7, 8), UVec4(0x80000000U, 0, 0x80000000U, 0)) == UVec4(5, 2, 7, 4));
CHECK(UVec4::sSelect(UVec4(1, 2, 3, 4), UVec4(5, 6, 7, 8), UVec4(0, 0x80000000U, 0, 0x80000000U)) == UVec4(1, 6, 3, 8));
CHECK(UVec4::sSelect(UVec4(1, 2, 3, 4), UVec4(5, 6, 7, 8), UVec4(0xffffffffU, 0x7fffffffU, 0xffffffffU, 0x7fffffffU)) == UVec4(5, 2, 7, 4));
CHECK(UVec4::sSelect(UVec4(1, 2, 3, 4), UVec4(5, 6, 7, 8), UVec4(0x7fffffffU, 0xffffffffU, 0x7fffffffU, 0xffffffffU)) == UVec4(1, 6, 3, 8));
}
TEST_CASE("TestUVec4BitOps")
{
// Test all bit permutations
UVec4 v1(0b0011, 0b00110, 0b001100, 0b0011000);
UVec4 v2(0b0101, 0b01010, 0b010100, 0b0101000);
CHECK(UVec4::sOr(v1, v2) == UVec4(0b0111, 0b01110, 0b011100, 0b0111000));
CHECK(UVec4::sXor(v1, v2) == UVec4(0b0110, 0b01100, 0b011000, 0b0110000));
CHECK(UVec4::sAnd(v1, v2) == UVec4(0b0001, 0b00010, 0b000100, 0b0001000));
CHECK(UVec4::sNot(v1) == UVec4(0xfffffffcU, 0xfffffff9U, 0xfffffff3U, 0xffffffe7U));
CHECK(UVec4::sNot(v2) == UVec4(0xfffffffaU, 0xfffffff5U, 0xffffffebU, 0xffffffd7U));
CHECK(UVec4(0x80000000U, 0x40000000U, 0x20000000U, 0x10000000U).LogicalShiftRight<1>() == UVec4(0x40000000U, 0x20000000U, 0x10000000U, 0x08000000U));
CHECK(UVec4(0x80000000U, 0x40000000U, 0x20000000U, 0x10000000U).ArithmeticShiftRight<1>() == UVec4(0xC0000000U, 0x20000000U, 0x10000000U, 0x08000000U));
CHECK(UVec4(0x40000000U, 0x20000000U, 0x10000000U, 0x08000001U).LogicalShiftLeft<1>() == UVec4(0x80000000U, 0x40000000U, 0x20000000U, 0x10000002U));
}
TEST_CASE("TestUVec4Operators")
{
CHECK(UVec4(1, 2, 3, 4) + UVec4(5, 6, 7, 8) == UVec4(6, 8, 10, 12));
CHECK(UVec4(5, 6, 7, 8) - UVec4(4, 3, 2, 1) == UVec4(1, 3, 5, 7));
CHECK(UVec4(1, 2, 3, 4) * UVec4(5, 6, 7, 8) == UVec4(1 * 5, 2 * 6, 3 * 7, 4 * 8));
UVec4 v = UVec4(1, 2, 3, 4);
v += UVec4(5, 6, 7, 8);
CHECK(v == UVec4(6, 8, 10, 12));
v -= UVec4(4, 3, 2, 1);
CHECK(v == UVec4(2, 5, 8, 11));
}
TEST_CASE("TestUVec4Swizzle")
{
UVec4 v(1, 2, 3, 4);
CHECK(v.SplatX() == UVec4::sReplicate(1));
CHECK(v.SplatY() == UVec4::sReplicate(2));
CHECK(v.SplatZ() == UVec4::sReplicate(3));
CHECK(v.SplatW() == UVec4::sReplicate(4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X>() == UVec4(1, 1, 1, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_Y>() == UVec4(1, 1, 1, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_Z>() == UVec4(1, 1, 1, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_W>() == UVec4(1, 1, 1, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_X>() == UVec4(1, 1, 2, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Y>() == UVec4(1, 1, 2, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z>() == UVec4(1, 1, 2, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_W>() == UVec4(1, 1, 2, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_X>() == UVec4(1, 1, 3, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Y>() == UVec4(1, 1, 3, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Z>() == UVec4(1, 1, 3, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_W>() == UVec4(1, 1, 3, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_W, SWIZZLE_X>() == UVec4(1, 1, 4, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_W, SWIZZLE_Y>() == UVec4(1, 1, 4, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_W, SWIZZLE_Z>() == UVec4(1, 1, 4, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_W, SWIZZLE_W>() == UVec4(1, 1, 4, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_X>() == UVec4(1, 2, 1, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Y>() == UVec4(1, 2, 1, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Z>() == UVec4(1, 2, 1, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_W>() == UVec4(1, 2, 1, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_X>() == UVec4(1, 2, 2, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y>() == UVec4(1, 2, 2, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Z>() == UVec4(1, 2, 2, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_W>() == UVec4(1, 2, 2, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>() == UVec4(1, 2, 3, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Y>() == UVec4(1, 2, 3, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z>() == UVec4(1, 2, 3, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W>() == UVec4(1, 2, 3, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_X>() == UVec4(1, 2, 4, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Y>() == UVec4(1, 2, 4, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Z>() == UVec4(1, 2, 4, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_W>() == UVec4(1, 2, 4, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_X>() == UVec4(1, 3, 1, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y>() == UVec4(1, 3, 1, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Z>() == UVec4(1, 3, 1, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_W>() == UVec4(1, 3, 1, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_X>() == UVec4(1, 3, 2, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Y>() == UVec4(1, 3, 2, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Z>() == UVec4(1, 3, 2, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_W>() == UVec4(1, 3, 2, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_X>() == UVec4(1, 3, 3, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Y>() == UVec4(1, 3, 3, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z>() == UVec4(1, 3, 3, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_W>() == UVec4(1, 3, 3, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_X>() == UVec4(1, 3, 4, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Y>() == UVec4(1, 3, 4, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Z>() == UVec4(1, 3, 4, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W>() == UVec4(1, 3, 4, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_X, SWIZZLE_X>() == UVec4(1, 4, 1, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_X, SWIZZLE_Y>() == UVec4(1, 4, 1, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_X, SWIZZLE_Z>() == UVec4(1, 4, 1, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_X, SWIZZLE_W>() == UVec4(1, 4, 1, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_X>() == UVec4(1, 4, 2, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Y>() == UVec4(1, 4, 2, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Z>() == UVec4(1, 4, 2, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_W>() == UVec4(1, 4, 2, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_X>() == UVec4(1, 4, 3, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Y>() == UVec4(1, 4, 3, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Z>() == UVec4(1, 4, 3, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_W>() == UVec4(1, 4, 3, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_W, SWIZZLE_X>() == UVec4(1, 4, 4, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_W, SWIZZLE_Y>() == UVec4(1, 4, 4, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_W, SWIZZLE_Z>() == UVec4(1, 4, 4, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_W, SWIZZLE_W>() == UVec4(1, 4, 4, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X>() == UVec4(2, 1, 1, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_X, SWIZZLE_Y>() == UVec4(2, 1, 1, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_X, SWIZZLE_Z>() == UVec4(2, 1, 1, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_X, SWIZZLE_W>() == UVec4(2, 1, 1, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_X>() == UVec4(2, 1, 2, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Y>() == UVec4(2, 1, 2, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z>() == UVec4(2, 1, 2, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_W>() == UVec4(2, 1, 2, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_X>() == UVec4(2, 1, 3, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Y>() == UVec4(2, 1, 3, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Z>() == UVec4(2, 1, 3, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_W>() == UVec4(2, 1, 3, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_W, SWIZZLE_X>() == UVec4(2, 1, 4, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_W, SWIZZLE_Y>() == UVec4(2, 1, 4, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_W, SWIZZLE_Z>() == UVec4(2, 1, 4, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_W, SWIZZLE_W>() == UVec4(2, 1, 4, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_X>() == UVec4(2, 2, 1, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Y>() == UVec4(2, 2, 1, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Z>() == UVec4(2, 2, 1, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_W>() == UVec4(2, 2, 1, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_X>() == UVec4(2, 2, 2, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y>() == UVec4(2, 2, 2, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Z>() == UVec4(2, 2, 2, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_W>() == UVec4(2, 2, 2, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>() == UVec4(2, 2, 3, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Y>() == UVec4(2, 2, 3, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z>() == UVec4(2, 2, 3, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W>() == UVec4(2, 2, 3, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_X>() == UVec4(2, 2, 4, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Y>() == UVec4(2, 2, 4, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Z>() == UVec4(2, 2, 4, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_W>() == UVec4(2, 2, 4, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_X>() == UVec4(2, 3, 1, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y>() == UVec4(2, 3, 1, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Z>() == UVec4(2, 3, 1, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_W>() == UVec4(2, 3, 1, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_X>() == UVec4(2, 3, 2, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Y>() == UVec4(2, 3, 2, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Z>() == UVec4(2, 3, 2, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_W>() == UVec4(2, 3, 2, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_X>() == UVec4(2, 3, 3, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Y>() == UVec4(2, 3, 3, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z>() == UVec4(2, 3, 3, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_W>() == UVec4(2, 3, 3, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_X>() == UVec4(2, 3, 4, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Y>() == UVec4(2, 3, 4, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Z>() == UVec4(2, 3, 4, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W>() == UVec4(2, 3, 4, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_X, SWIZZLE_X>() == UVec4(2, 4, 1, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_X, SWIZZLE_Y>() == UVec4(2, 4, 1, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_X, SWIZZLE_Z>() == UVec4(2, 4, 1, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_X, SWIZZLE_W>() == UVec4(2, 4, 1, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_X>() == UVec4(2, 4, 2, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Y>() == UVec4(2, 4, 2, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Z>() == UVec4(2, 4, 2, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_W>() == UVec4(2, 4, 2, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_X>() == UVec4(2, 4, 3, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Y>() == UVec4(2, 4, 3, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Z>() == UVec4(2, 4, 3, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_W>() == UVec4(2, 4, 3, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_W, SWIZZLE_X>() == UVec4(2, 4, 4, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_W, SWIZZLE_Y>() == UVec4(2, 4, 4, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_W, SWIZZLE_Z>() == UVec4(2, 4, 4, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_W, SWIZZLE_W>() == UVec4(2, 4, 4, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X>() == UVec4(3, 1, 1, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_X, SWIZZLE_Y>() == UVec4(3, 1, 1, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_X, SWIZZLE_Z>() == UVec4(3, 1, 1, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_X, SWIZZLE_W>() == UVec4(3, 1, 1, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_X>() == UVec4(3, 1, 2, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Y>() == UVec4(3, 1, 2, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z>() == UVec4(3, 1, 2, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_W>() == UVec4(3, 1, 2, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_X>() == UVec4(3, 1, 3, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Y>() == UVec4(3, 1, 3, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Z>() == UVec4(3, 1, 3, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_W>() == UVec4(3, 1, 3, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_W, SWIZZLE_X>() == UVec4(3, 1, 4, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_W, SWIZZLE_Y>() == UVec4(3, 1, 4, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_W, SWIZZLE_Z>() == UVec4(3, 1, 4, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_W, SWIZZLE_W>() == UVec4(3, 1, 4, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_X>() == UVec4(3, 2, 1, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Y>() == UVec4(3, 2, 1, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Z>() == UVec4(3, 2, 1, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_W>() == UVec4(3, 2, 1, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_X>() == UVec4(3, 2, 2, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y>() == UVec4(3, 2, 2, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Z>() == UVec4(3, 2, 2, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_W>() == UVec4(3, 2, 2, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>() == UVec4(3, 2, 3, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Y>() == UVec4(3, 2, 3, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z>() == UVec4(3, 2, 3, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W>() == UVec4(3, 2, 3, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_X>() == UVec4(3, 2, 4, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Y>() == UVec4(3, 2, 4, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Z>() == UVec4(3, 2, 4, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_W>() == UVec4(3, 2, 4, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_X>() == UVec4(3, 3, 1, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y>() == UVec4(3, 3, 1, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Z>() == UVec4(3, 3, 1, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_W>() == UVec4(3, 3, 1, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_X>() == UVec4(3, 3, 2, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Y>() == UVec4(3, 3, 2, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Z>() == UVec4(3, 3, 2, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_W>() == UVec4(3, 3, 2, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_X>() == UVec4(3, 3, 3, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Y>() == UVec4(3, 3, 3, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z>() == UVec4(3, 3, 3, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_W>() == UVec4(3, 3, 3, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_X>() == UVec4(3, 3, 4, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Y>() == UVec4(3, 3, 4, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Z>() == UVec4(3, 3, 4, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W>() == UVec4(3, 3, 4, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_X, SWIZZLE_X>() == UVec4(3, 4, 1, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_X, SWIZZLE_Y>() == UVec4(3, 4, 1, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_X, SWIZZLE_Z>() == UVec4(3, 4, 1, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_X, SWIZZLE_W>() == UVec4(3, 4, 1, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_X>() == UVec4(3, 4, 2, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Y>() == UVec4(3, 4, 2, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Z>() == UVec4(3, 4, 2, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_W>() == UVec4(3, 4, 2, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_X>() == UVec4(3, 4, 3, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Y>() == UVec4(3, 4, 3, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Z>() == UVec4(3, 4, 3, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_W>() == UVec4(3, 4, 3, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W, SWIZZLE_X>() == UVec4(3, 4, 4, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W, SWIZZLE_Y>() == UVec4(3, 4, 4, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W, SWIZZLE_Z>() == UVec4(3, 4, 4, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W, SWIZZLE_W>() == UVec4(3, 4, 4, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X>() == UVec4(4, 1, 1, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_X, SWIZZLE_Y>() == UVec4(4, 1, 1, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_X, SWIZZLE_Z>() == UVec4(4, 1, 1, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_X, SWIZZLE_W>() == UVec4(4, 1, 1, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_X>() == UVec4(4, 1, 2, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Y>() == UVec4(4, 1, 2, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z>() == UVec4(4, 1, 2, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_W>() == UVec4(4, 1, 2, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_X>() == UVec4(4, 1, 3, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Y>() == UVec4(4, 1, 3, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Z>() == UVec4(4, 1, 3, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_W>() == UVec4(4, 1, 3, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_W, SWIZZLE_X>() == UVec4(4, 1, 4, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_W, SWIZZLE_Y>() == UVec4(4, 1, 4, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_W, SWIZZLE_Z>() == UVec4(4, 1, 4, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_W, SWIZZLE_W>() == UVec4(4, 1, 4, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_X>() == UVec4(4, 2, 1, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Y>() == UVec4(4, 2, 1, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Z>() == UVec4(4, 2, 1, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_W>() == UVec4(4, 2, 1, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_X>() == UVec4(4, 2, 2, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y>() == UVec4(4, 2, 2, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Z>() == UVec4(4, 2, 2, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_W>() == UVec4(4, 2, 2, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>() == UVec4(4, 2, 3, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Y>() == UVec4(4, 2, 3, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z>() == UVec4(4, 2, 3, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W>() == UVec4(4, 2, 3, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_X>() == UVec4(4, 2, 4, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Y>() == UVec4(4, 2, 4, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Z>() == UVec4(4, 2, 4, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_W>() == UVec4(4, 2, 4, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_X>() == UVec4(4, 3, 1, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y>() == UVec4(4, 3, 1, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Z>() == UVec4(4, 3, 1, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_W>() == UVec4(4, 3, 1, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_X>() == UVec4(4, 3, 2, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Y>() == UVec4(4, 3, 2, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Z>() == UVec4(4, 3, 2, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_W>() == UVec4(4, 3, 2, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_X>() == UVec4(4, 3, 3, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Y>() == UVec4(4, 3, 3, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z>() == UVec4(4, 3, 3, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_W>() == UVec4(4, 3, 3, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_X>() == UVec4(4, 3, 4, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Y>() == UVec4(4, 3, 4, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Z>() == UVec4(4, 3, 4, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W>() == UVec4(4, 3, 4, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_X, SWIZZLE_X>() == UVec4(4, 4, 1, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_X, SWIZZLE_Y>() == UVec4(4, 4, 1, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_X, SWIZZLE_Z>() == UVec4(4, 4, 1, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_X, SWIZZLE_W>() == UVec4(4, 4, 1, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_X>() == UVec4(4, 4, 2, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Y>() == UVec4(4, 4, 2, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Z>() == UVec4(4, 4, 2, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_W>() == UVec4(4, 4, 2, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_X>() == UVec4(4, 4, 3, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Y>() == UVec4(4, 4, 3, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Z>() == UVec4(4, 4, 3, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_W>() == UVec4(4, 4, 3, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_W, SWIZZLE_X>() == UVec4(4, 4, 4, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_W, SWIZZLE_Y>() == UVec4(4, 4, 4, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_W, SWIZZLE_Z>() == UVec4(4, 4, 4, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_W, SWIZZLE_W>() == UVec4(4, 4, 4, 4));
}
TEST_CASE("TestUVec4Dot")
{
CHECK(UVec4(1, 2, 3, 4).Dot(UVec4(5, 6, 7, 8)) == 1 * 5 + 2 * 6 + 3 * 7 + 4 * 8);
CHECK(UVec4(1, 2, 3, 4).DotV(UVec4(5, 6, 7, 8)) == UVec4::sReplicate(1 * 5 + 2 * 6 + 3 * 7 + 4 * 8));
}
TEST_CASE("TestUVec4Cast")
{
CHECK(UVec4(1, 2, 3, 4).ToFloat() == Vec4(1, 2, 3, 4));
CHECK(UVec4(0x3f800000U, 0x40000000U, 0x40400000U, 0x40800000U).ReinterpretAsFloat() == Vec4(1, 2, 3, 4));
}
TEST_CASE("TestUVec4ExtractUInt16")
{
uint32 data[] = { 0x0b020a01, 0x0d040c03, 0x0b060a05, 0x0d080c07 };
UVec4 vector = UVec4::sLoadInt4(data);
CHECK(vector.Expand4Uint16Lo() == UVec4(0x0a01, 0x0b02, 0x0c03, 0x0d04));
CHECK(vector.Expand4Uint16Hi() == UVec4(0x0a05, 0x0b06, 0x0c07, 0x0d08));
}
TEST_CASE("TestUVec4ExtractBytes")
{
uint32 data[] = { 0x14131211, 0x24232221, 0x34333231, 0x44434241 };
UVec4 vector = UVec4::sLoadInt4(data);
CHECK(vector.Expand4Byte0() == UVec4(0x11, 0x12, 0x13, 0x14));
CHECK(vector.Expand4Byte4() == UVec4(0x21, 0x22, 0x23, 0x24));
CHECK(vector.Expand4Byte8() == UVec4(0x31, 0x32, 0x33, 0x34));
CHECK(vector.Expand4Byte12() == UVec4(0x41, 0x42, 0x43, 0x44));
}
TEST_CASE("TestUVec4ShiftComponents")
{
UVec4 v(1, 2, 3, 4);
CHECK(v.ShiftComponents4Minus(4) == UVec4(1, 2, 3, 4));
CHECK(v.ShiftComponents4Minus(3) == UVec4(2, 3, 4, 0));
CHECK(v.ShiftComponents4Minus(2) == UVec4(3, 4, 0, 0));
CHECK(v.ShiftComponents4Minus(1) == UVec4(4, 0, 0, 0));
CHECK(v.ShiftComponents4Minus(0) == UVec4(0, 0, 0, 0));
}
TEST_CASE("TestUVec4Sort4True")
{
CHECK(UVec4::sSort4True(UVec4(0x00000000U, 0x00000000U, 0x00000000U, 0x00000000U), UVec4(1, 2, 3, 4)) == UVec4(4, 4, 4, 4));
CHECK(UVec4::sSort4True(UVec4(0xffffffffU, 0x00000000U, 0x00000000U, 0x00000000U), UVec4(1, 2, 3, 4)) == UVec4(1, 4, 4, 4));
CHECK(UVec4::sSort4True(UVec4(0x00000000U, 0xffffffffU, 0x00000000U, 0x00000000U), UVec4(1, 2, 3, 4)) == UVec4(2, 4, 4, 4));
CHECK(UVec4::sSort4True(UVec4(0xffffffffU, 0xffffffffU, 0x00000000U, 0x00000000U), UVec4(1, 2, 3, 4)) == UVec4(1, 2, 4, 4));
CHECK(UVec4::sSort4True(UVec4(0x00000000U, 0x00000000U, 0xffffffffU, 0x00000000U), UVec4(1, 2, 3, 4)) == UVec4(3, 4, 4, 4));
CHECK(UVec4::sSort4True(UVec4(0xffffffffU, 0x00000000U, 0xffffffffU, 0x00000000U), UVec4(1, 2, 3, 4)) == UVec4(1, 3, 4, 4));
CHECK(UVec4::sSort4True(UVec4(0x00000000U, 0xffffffffU, 0xffffffffU, 0x00000000U), UVec4(1, 2, 3, 4)) == UVec4(2, 3, 4, 4));
CHECK(UVec4::sSort4True(UVec4(0xffffffffU, 0xffffffffU, 0xffffffffU, 0x00000000U), UVec4(1, 2, 3, 4)) == UVec4(1, 2, 3, 4));
CHECK(UVec4::sSort4True(UVec4(0x00000000U, 0x00000000U, 0x00000000U, 0xffffffffU), UVec4(1, 2, 3, 4)) == UVec4(4, 4, 4, 4));
CHECK(UVec4::sSort4True(UVec4(0xffffffffU, 0x00000000U, 0x00000000U, 0xffffffffU), UVec4(1, 2, 3, 4)) == UVec4(1, 4, 4, 4));
CHECK(UVec4::sSort4True(UVec4(0x00000000U, 0xffffffffU, 0x00000000U, 0xffffffffU), UVec4(1, 2, 3, 4)) == UVec4(2, 4, 4, 4));
CHECK(UVec4::sSort4True(UVec4(0xffffffffU, 0xffffffffU, 0x00000000U, 0xffffffffU), UVec4(1, 2, 3, 4)) == UVec4(1, 2, 4, 4));
CHECK(UVec4::sSort4True(UVec4(0x00000000U, 0x00000000U, 0xffffffffU, 0xffffffffU), UVec4(1, 2, 3, 4)) == UVec4(3, 4, 4, 4));
CHECK(UVec4::sSort4True(UVec4(0xffffffffU, 0x00000000U, 0xffffffffU, 0xffffffffU), UVec4(1, 2, 3, 4)) == UVec4(1, 3, 4, 4));
CHECK(UVec4::sSort4True(UVec4(0x00000000U, 0xffffffffU, 0xffffffffU, 0xffffffffU), UVec4(1, 2, 3, 4)) == UVec4(2, 3, 4, 4));
CHECK(UVec4::sSort4True(UVec4(0xffffffffU, 0xffffffffU, 0xffffffffU, 0xffffffffU), UVec4(1, 2, 3, 4)) == UVec4(1, 2, 3, 4));
}
TEST_CASE("TestUVec4ConvertToString")
{
UVec4 v(1, 2, 3, 4);
CHECK(ConvertToString(v) == "1, 2, 3, 4");
}
}

408
lib/All/JoltPhysics/UnitTests/Math/Vec3Tests.cpp Normal file
View File

@@ -0,0 +1,408 @@
// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
#include "UnitTestFramework.h"
#include <Jolt/Core/StringTools.h>
TEST_SUITE("Vec3Tests")
{
TEST_CASE("TestVec3ConstructComponents")
{
Vec3 v(1, 2, 3);
// Test component access
CHECK(v.GetX() == 1);
CHECK(v.GetY() == 2);
CHECK(v.GetZ() == 3);
// Test component access by [] operators
CHECK(v[0] == 1);
CHECK(v[1] == 2);
CHECK(v[2] == 3);
// Test == and != operators
CHECK(v == Vec3(1, 2, 3));
CHECK(v != Vec3(1, 2, 4));
// Set the components
v.SetComponent(0, 4);
v.SetComponent(1, 5);
v.SetComponent(2, 6);
CHECK(v == Vec3(4, 5, 6));
// Set the components
v.SetX(7);
v.SetY(8);
v.SetZ(9);
CHECK(v == Vec3(7, 8, 9));
// Set all components
v.Set(10, 11, 12);
CHECK(v == Vec3(10, 11, 12));
}
TEST_CASE("TestVec3LoadStoreFloat3")
{
float f4[] = { 1, 2, 3, 4 }; // Extra element since we read one too many in sLoadFloat3Unsafe
Float3 &f3 = *(Float3 *)f4;
CHECK(Vec3(f3) == Vec3(1, 2, 3));
CHECK(Vec3::sLoadFloat3Unsafe(f3) == Vec3(1, 2, 3));
Float3 f3_out;
Vec3(1, 2, 3).StoreFloat3(&f3_out);
CHECK(f3 == f3_out);
}
TEST_CASE("TestVec3ConstructVec4")
{
Vec4 v4(1, 2, 3, 4);
CHECK(Vec3(v4) == Vec3(1, 2, 3));
}
TEST_CASE("TestVec3Zero")
{
Vec3 v = Vec3::sZero();
CHECK(v.GetX() == 0);
CHECK(v.GetY() == 0);
CHECK(v.GetZ() == 0);
}
TEST_CASE("TestVec3NaN")
{
Vec3 v = Vec3::sNaN();
CHECK(isnan(v.GetX()));
CHECK(isnan(v.GetY()));
CHECK(isnan(v.GetZ()));
CHECK(v.IsNaN());
v.SetComponent(0, 0);
CHECK(v.IsNaN());
v.SetComponent(1, 0);
CHECK(v.IsNaN());
v.SetComponent(2, 0);
CHECK(!v.IsNaN());
}
TEST_CASE("TestVec3Replicate")
{
CHECK(Vec3::sReplicate(2) == Vec3(2, 2, 2));
}
TEST_CASE("TestVec3MinMax")
{
Vec3 v1(1, 5, 3);
Vec3 v2(4, 2, 6);
Vec3 v3(6, 4, 2);
CHECK(Vec3::sMin(v1, v2) == Vec3(1, 2, 3));
CHECK(Vec3::sMax(v1, v2) == Vec3(4, 5, 6));
CHECK(v1.ReduceMin() == 1);
CHECK(v1.ReduceMax() == 5);
CHECK(v2.ReduceMin() == 2);
CHECK(v2.ReduceMax() == 6);
CHECK(v1.GetLowestComponentIndex() == 0);
CHECK(v1.GetHighestComponentIndex() == 1);
CHECK(v2.GetLowestComponentIndex() == 1);
CHECK(v2.GetHighestComponentIndex() == 2);
CHECK(v3.GetLowestComponentIndex() == 2);
CHECK(v3.GetHighestComponentIndex() == 0);
}
TEST_CASE("TestVec3Clamp")
{
Vec3 v1(1, 2, 3);
Vec3 v2(4, 5, 6);
Vec3 v(-1, 3, 7);
CHECK(Vec3::sClamp(v, v1, v2) == Vec3(1, 3, 6));
}
TEST_CASE("TestVec3Comparisons")
{
CHECK(Vec3::sEquals(Vec3(1, 2, 3), Vec3(1, 4, 3)) == UVec4(0xffffffffU, 0, 0xffffffffU, 0xffffffffU)); // W is always Z for comparisons
CHECK(Vec3::sLess(Vec3(1, 2, 4), Vec3(1, 4, 3)) == UVec4(0, 0xffffffffU, 0, 0));
CHECK(Vec3::sLessOrEqual(Vec3(1, 2, 4), Vec3(1, 4, 3)) == UVec4(0xffffffffU, 0xffffffffU, 0, 0));
CHECK(Vec3::sGreater(Vec3(1, 2, 4), Vec3(1, 4, 3)) == UVec4(0, 0, 0xffffffffU, 0xffffffffU));
CHECK(Vec3::sGreaterOrEqual(Vec3(1, 2, 4), Vec3(1, 4, 3)) == UVec4(0xffffffffU, 0, 0xffffffffU, 0xffffffffU));
}
TEST_CASE("TestVec3FMA")
{
CHECK(Vec3::sFusedMultiplyAdd(Vec3(1, 2, 3), Vec3(4, 5, 6), Vec3(7, 8, 9)) == Vec3(1 * 4 + 7, 2 * 5 + 8, 3 * 6 + 9));
}
TEST_CASE("TestVec3Select")
{
CHECK(Vec3::sSelect(Vec3(1, 2, 3), Vec3(4, 5, 6), UVec4(0x80000000U, 0, 0x80000000U, 0)) == Vec3(4, 2, 6));
CHECK(Vec3::sSelect(Vec3(1, 2, 3), Vec3(4, 5, 6), UVec4(0, 0x80000000U, 0, 0x80000000U)) == Vec3(1, 5, 3));
CHECK(Vec3::sSelect(Vec3(1, 2, 3), Vec3(4, 5, 6), UVec4(0xffffffffU, 0x7fffffffU, 0xffffffffU, 0x7fffffffU)) == Vec3(4, 2, 6));
CHECK(Vec3::sSelect(Vec3(1, 2, 3), Vec3(4, 5, 6), UVec4(0x7fffffffU, 0xffffffffU, 0x7fffffffU, 0xffffffffU)) == Vec3(1, 5, 3));
}
TEST_CASE("TestVec3BitOps")
{
// Test all bit permutations
Vec3 v1(UVec4(0b0011, 0b00110, 0b001100, 0).ReinterpretAsFloat());
Vec3 v2(UVec4(0b0101, 0b01010, 0b010100, 0).ReinterpretAsFloat());
CHECK(Vec3::sOr(v1, v2) == Vec3(UVec4(0b0111, 0b01110, 0b011100, 0).ReinterpretAsFloat()));
CHECK(Vec3::sXor(v1, v2) == Vec3(UVec4(0b0110, 0b01100, 0b011000, 0).ReinterpretAsFloat()));
CHECK(Vec3::sAnd(v1, v2) == Vec3(UVec4(0b0001, 0b00010, 0b000100, 0).ReinterpretAsFloat()));
}
TEST_CASE("TestVec3Close")
{
CHECK(Vec3(1, 2, 3).IsClose(Vec3(1.001f, 2.001f, 3.001f), 1.0e-4f));
CHECK(!Vec3(1, 2, 3).IsClose(Vec3(1.001f, 2.001f, 3.001f), 1.0e-6f));
CHECK(Vec3(1.001f, 0, 0).IsNormalized(1.0e-2f));
CHECK(!Vec3(0, 1.001f, 0).IsNormalized(1.0e-4f));
CHECK(Vec3(-1.0e-7f, 1.0e-7f, 1.0e-8f).IsNearZero());
CHECK(!Vec3(-1.0e-7f, 1.0e-7f, -1.0e-5f).IsNearZero());
}
TEST_CASE("TestVec3Operators")
{
CHECK(-Vec3(1, 2, 3) == Vec3(-1, -2, -3));
Vec3 neg_zero = -Vec3::sZero();
CHECK(neg_zero == Vec3::sZero());
#ifdef JPH_CROSS_PLATFORM_DETERMINISTIC
// When cross platform deterministic, we want to make sure that -0 is represented as 0
UVec4 neg_zero_bin = neg_zero.ReinterpretAsInt();
CHECK(neg_zero_bin.GetX() == 0);
CHECK(neg_zero_bin.GetY() == 0);
CHECK(neg_zero_bin.GetZ() == 0);
#endif // JPH_CROSS_PLATFORM_DETERMINISTIC
CHECK(Vec3(1, 2, 3) + Vec3(4, 5, 6) == Vec3(5, 7, 9));
CHECK(Vec3(1, 2, 3) - Vec3(6, 5, 4) == Vec3(-5, -3, -1));
CHECK(Vec3(1, 2, 3) * Vec3(4, 5, 6) == Vec3(4, 10, 18));
CHECK(Vec3(1, 2, 3) * 2 == Vec3(2, 4, 6));
CHECK(4 * Vec3(1, 2, 3) == Vec3(4, 8, 12));
CHECK(Vec3(1, 2, 3) / 2 == Vec3(0.5f, 1.0f, 1.5f));
CHECK(Vec3(1, 2, 3) / Vec3(2, 8, 24) == Vec3(0.5f, 0.25f, 0.125f));
Vec3 v = Vec3(1, 2, 3);
v *= Vec3(4, 5, 6);
CHECK(v == Vec3(4, 10, 18));
v *= 2;
CHECK(v == Vec3(8, 20, 36));
v /= 2;
CHECK(v == Vec3(4, 10, 18));
v += Vec3(1, 2, 3);
CHECK(v == Vec3(5, 12, 21));
v -= Vec3(1, 2, 3);
CHECK(v == Vec3(4, 10, 18));
CHECK(Vec3(2, 4, 8).Reciprocal() == Vec3(0.5f, 0.25f, 0.125f));
}
TEST_CASE("TestVec3Swizzle")
{
Vec3 v(1, 2, 3);
CHECK(v.SplatX() == Vec4::sReplicate(1));
CHECK(v.SplatY() == Vec4::sReplicate(2));
CHECK(v.SplatZ() == Vec4::sReplicate(3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_X>() == Vec3(1, 1, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_Y>() == Vec3(1, 1, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_Z>() == Vec3(1, 1, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_X>() == Vec3(1, 2, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Y>() == Vec3(1, 2, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z>() == Vec3(1, 2, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_X>() == Vec3(1, 3, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Y>() == Vec3(1, 3, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Z>() == Vec3(1, 3, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_X>() == Vec3(2, 1, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Y>() == Vec3(2, 1, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Z>() == Vec3(2, 1, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_X>() == Vec3(2, 2, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y>() == Vec3(2, 2, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Z>() == Vec3(2, 2, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>() == Vec3(2, 3, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Y>() == Vec3(2, 3, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z>() == Vec3(2, 3, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_X>() == Vec3(3, 1, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y>() == Vec3(3, 1, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Z>() == Vec3(3, 1, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_X>() == Vec3(3, 2, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Y>() == Vec3(3, 2, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Z>() == Vec3(3, 2, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_X>() == Vec3(3, 3, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Y>() == Vec3(3, 3, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z>() == Vec3(3, 3, 3));
}
TEST_CASE("TestVec3Abs")
{
CHECK(Vec3(1, -2, 3).Abs() == Vec3(1, 2, 3));
CHECK(Vec3(-1, 2, -3).Abs() == Vec3(1, 2, 3));
}
TEST_CASE("TestVec3Dot")
{
CHECK(Vec3(1, 2, 3).Dot(Vec3(4, 5, 6)) == float(1 * 4 + 2 * 5 + 3 * 6));
CHECK(Vec3(1, 2, 3).DotV(Vec3(4, 5, 6)) == Vec3::sReplicate(1 * 4 + 2 * 5 + 3 * 6));
CHECK(Vec3(1, 2, 3).DotV4(Vec3(4, 5, 6)) == Vec4::sReplicate(1 * 4 + 2 * 5 + 3 * 6));
}
TEST_CASE("TestVec3Length")
{
CHECK(Vec3(1, 2, 3).LengthSq() == float(1 + 4 + 9));
CHECK(Vec3(1, 2, 3).Length() == sqrt(float(1 + 4 + 9)));
}
TEST_CASE("TestVec3Sqrt")
{
CHECK_APPROX_EQUAL(Vec3(13, 15, 17).Sqrt(), Vec3(sqrt(13.0f), sqrt(15.0f), sqrt(17.0f)));
}
TEST_CASE("TestVec3Cross")
{
CHECK(Vec3(1, 0, 0).Cross(Vec3(0, 1, 0)) == Vec3(0, 0, 1));
CHECK(Vec3(0, 1, 0).Cross(Vec3(1, 0, 0)) == Vec3(0, 0, -1));
CHECK(Vec3(0, 1, 0).Cross(Vec3(0, 0, 1)) == Vec3(1, 0, 0));
CHECK(Vec3(0, 0, 1).Cross(Vec3(0, 1, 0)) == Vec3(-1, 0, 0));
CHECK(Vec3(0, 0, 1).Cross(Vec3(1, 0, 0)) == Vec3(0, 1, 0));
CHECK(Vec3(1, 0, 0).Cross(Vec3(0, 0, 1)) == Vec3(0, -1, 0));
}
TEST_CASE("TestVec3Normalize")
{
CHECK(Vec3(3, 2, 1).Normalized() == Vec3(3, 2, 1) / sqrt(9.0f + 4.0f + 1.0f));
CHECK(Vec3(3, 2, 1).NormalizedOr(Vec3(1, 2, 3)) == Vec3(3, 2, 1) / sqrt(9.0f + 4.0f + 1.0f));
CHECK(Vec3::sZero().NormalizedOr(Vec3(1, 2, 3)) == Vec3(1, 2, 3));
CHECK(Vec3(0.999f * sqrt(FLT_MIN), 0, 0).NormalizedOr(Vec3(1, 2, 3)) == Vec3(1, 2, 3)); // A vector that has a squared length that is denormal should also be treated as zero
CHECK_APPROX_EQUAL(Vec3(1.001f * sqrt(FLT_MIN), 0, 0).NormalizedOr(Vec3(1, 2, 3)), Vec3(1, 0, 0)); // A value that is just above being denormal should work normally
}
TEST_CASE("TestVec3Cast")
{
CHECK(UVec4::sEquals(Vec3(1, 2, 3).ToInt(), UVec4(1, 2, 3, 0)).TestAllXYZTrue());
CHECK(UVec4::sEquals(Vec3(1, 2, 3).ReinterpretAsInt(), UVec4(0x3f800000U, 0x40000000U, 0x40400000U, 0)).TestAllXYZTrue());
}
TEST_CASE("TestVec3NormalizedPerpendicular")
{
UnitTestRandom random;
uniform_real_distribution<float> one_to_ten(1.0f, 10.0f);
for (int i = 0; i < 100; ++i)
{
Vec3 v = Vec3::sRandom(random);
CHECK(v.IsNormalized());
v *= one_to_ten(random);
Vec3 p = v.GetNormalizedPerpendicular();
CHECK(p.IsNormalized());
CHECK(abs(v.Dot(p)) < 1.0e-6f);
}
}
TEST_CASE("TestVec3Sign")
{
CHECK(Vec3(1.2345f, -6.7891f, 0).GetSign() == Vec3(1, -1, 1));
CHECK(Vec3(0, 2.3456f, -7.8912f).GetSign() == Vec3(1, 1, -1));
}
TEST_CASE("TestVec3FlipSign")
{
Vec3 v(1, 2, 3);
CHECK(v.FlipSign<-1, 1, 1>() == Vec3(-1, 2, 3));
CHECK(v.FlipSign<1, -1, 1>() == Vec3(1, -2, 3));
CHECK(v.FlipSign<1, 1, -1>() == Vec3(1, 2, -3));
}
#ifdef JPH_FLOATING_POINT_EXCEPTIONS_ENABLED
TEST_CASE("TestVec3SyncW")
{
{
// Check that W equals Z
Vec3 v(1, 2, 3);
CHECK(Vec4(v) == Vec4(1, 2, 3, 3));
}
{
// Check that setting individual components syncs W and Z
Vec3 v;
v.SetComponent(2, 3);
v.SetComponent(1, 2);
v.SetComponent(0, 1);
CHECK(v == Vec3(1, 2, 3));
CHECK(Vec4(v) == Vec4(1, 2, 3, 3));
}
{
// Check that W and Z are still synced after a simple addition
CHECK(Vec4(Vec3(1, 2, 3) + Vec3(4, 5, 6)) == Vec4(5, 7, 9, 9));
}
{
// Test that casting a Vec4 to Vec3 syncs W and Z
CHECK(Vec4(Vec3(Vec4(1, 2, 3, 4))) == Vec4(1, 2, 3, 3));
}
{
// Test that loading from Float3 syncs W and Z
CHECK(Vec4(Vec3(Float3(1, 2, 3))) == Vec4(1, 2, 3, 3));
}
{
// Test that loading unsafe from Float3 syncs W and Z
Float4 v(1, 2, 3, 4);
CHECK(Vec4(Vec3::sLoadFloat3Unsafe(*(Float3 *)&v)) == Vec4(1, 2, 3, 3));
}
{
// Test swizzle syncs W and Z
CHECK(Vec4(Vec3(1, 2, 3).Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_X>()) == Vec4(3, 2, 1, 1));
}
{
// Test cross product syncs W and Z
CHECK(Vec4(Vec3(1, 0, 0).Cross(Vec3(0, 1, 0))) == Vec4(0, 0, 1, 1));
CHECK(Vec4(Vec3(0, 1, 0).Cross(Vec3(0, 0, 1))) == Vec4(1, 0, 0, 0));
}
}
#endif // JPH_FLOATING_POINT_EXCEPTIONS_ENABLED
TEST_CASE("TestVec3ConvertToString")
{
Vec3 v(1, 2, 3);
CHECK(ConvertToString(v) == "1, 2, 3");
}
TEST_CASE("TestVec3CompressUnitVector")
{
// We want these to be preserved exactly
CHECK(Vec3::sDecompressUnitVector(Vec3::sAxisX().CompressUnitVector()) == Vec3::sAxisX());
CHECK(Vec3::sDecompressUnitVector(Vec3::sAxisY().CompressUnitVector()) == Vec3::sAxisY());
CHECK(Vec3::sDecompressUnitVector(Vec3::sAxisZ().CompressUnitVector()) == Vec3::sAxisZ());
CHECK(Vec3::sDecompressUnitVector((-Vec3::sAxisX()).CompressUnitVector()) == -Vec3::sAxisX());
CHECK(Vec3::sDecompressUnitVector((-Vec3::sAxisY()).CompressUnitVector()) == -Vec3::sAxisY());
CHECK(Vec3::sDecompressUnitVector((-Vec3::sAxisZ()).CompressUnitVector()) == -Vec3::sAxisZ());
UnitTestRandom random;
for (int i = 0; i < 1000; ++i)
{
Vec3 v = Vec3::sRandom(random);
uint32 compressed = v.CompressUnitVector();
Vec3 decompressed = Vec3::sDecompressUnitVector(compressed);
float diff = (decompressed - v).Length();
CHECK(diff < 1.0e-4f);
}
}
}

795
lib/All/JoltPhysics/UnitTests/Math/Vec4Tests.cpp Normal file
View File

@@ -0,0 +1,795 @@
// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
#include "UnitTestFramework.h"
#include <Jolt/Core/StringTools.h>
TEST_SUITE("Vec4Tests")
{
TEST_CASE("TestVec4Construct")
{
Vec4 v(1, 2, 3, 4);
// Test component access
CHECK(v.GetX() == 1);
CHECK(v.GetY() == 2);
CHECK(v.GetZ() == 3);
CHECK(v.GetW() == 4);
// Test component access by [] operators
CHECK(v[0] == 1);
CHECK(v[1] == 2);
CHECK(v[2] == 3);
CHECK(v[3] == 4);
// Test == and != operators
CHECK(v == Vec4(1, 2, 3, 4));
CHECK(v != Vec4(1, 2, 4, 3));
}
TEST_CASE("TestVec4LoadStoreFloat4")
{
alignas(16) Float4 f4 = { 1, 2, 3, 4 };
CHECK(Vec4::sLoadFloat4(&f4) == Vec4(1, 2, 3, 4));
CHECK(Vec4::sLoadFloat4Aligned(&f4) == Vec4(1, 2, 3, 4));
Float4 f4_out;
Vec4(1, 2, 3, 4).StoreFloat4(&f4_out);
CHECK(f4_out[0] == 1);
CHECK(f4_out[1] == 2);
CHECK(f4_out[2] == 3);
CHECK(f4_out[3] == 4);
float sf[] = { 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 4, 0 };
CHECK(Vec4::sGatherFloat4<2 * sizeof(float)>(sf, UVec4(1, 3, 8, 9)) == Vec4(1, 2, 3, 4));
}
TEST_CASE("TestVec4ConstructVec3")
{
Vec3 v3(1, 2, 3);
CHECK(Vec4(v3, 4) == Vec4(1, 2, 3, 4));
}
TEST_CASE("TestVec4Zero")
{
Vec4 v = Vec4::sZero();
CHECK(v.GetX() == 0);
CHECK(v.GetY() == 0);
CHECK(v.GetZ() == 0);
CHECK(v.GetW() == 0);
}
TEST_CASE("TestVec4NaN")
{
Vec4 v = Vec4::sNaN();
CHECK(isnan(v.GetX()));
CHECK(isnan(v.GetY()));
CHECK(isnan(v.GetZ()));
CHECK(isnan(v.GetW()));
CHECK(v.IsNaN());
v.SetX(0);
CHECK(v.IsNaN());
v.SetY(0);
CHECK(v.IsNaN());
v.SetZ(0);
CHECK(v.IsNaN());
v.SetW(0);
CHECK(!v.IsNaN());
}
TEST_CASE("TestVec4Replicate")
{
CHECK(Vec4::sReplicate(2) == Vec4(2, 2, 2, 2));
}
TEST_CASE("TestVec4MinMax")
{
Vec4 v1(1, 6, 3, 8);
Vec4 v2(5, 2, 7, 4);
Vec4 v3(5, 7, 2, 4);
Vec4 v4(7, 5, 4, 2);
CHECK(Vec4::sMin(v1, v2) == Vec4(1, 2, 3, 4));
CHECK(Vec4::sMax(v1, v2) == Vec4(5, 6, 7, 8));
CHECK(v1.ReduceMin() == 1);
CHECK(v1.ReduceMax() == 8);
CHECK(v2.ReduceMin() == 2);
CHECK(v2.ReduceMax() == 7);
CHECK(v1.GetLowestComponentIndex() == 0);
CHECK(v1.GetHighestComponentIndex() == 3);
CHECK(v2.GetLowestComponentIndex() == 1);
CHECK(v2.GetHighestComponentIndex() == 2);
CHECK(v3.GetLowestComponentIndex() == 2);
CHECK(v3.GetHighestComponentIndex() == 1);
CHECK(v4.GetLowestComponentIndex() == 3);
CHECK(v4.GetHighestComponentIndex() == 0);
}
TEST_CASE("TestVec4Clamp")
{
Vec4 v1(1, 2, 3, 4);
Vec4 v2(5, 6, 7, 8);
Vec4 v(-1, 3, 9, -11);
CHECK(Vec4::sClamp(v, v1, v2) == Vec4(1, 3, 7, 4));
}
TEST_CASE("TestVec4Comparisons")
{
CHECK(Vec4::sEquals(Vec4(1, 2, 3, 4), Vec4(2, 1, 3, 4)) == UVec4(0, 0, 0xffffffffU, 0xffffffffU));
CHECK(Vec4::sLess(Vec4(1, 2, 3, 4), Vec4(2, 1, 3, 4)) == UVec4(0xffffffffU, 0, 0, 0));
CHECK(Vec4::sLessOrEqual(Vec4(1, 2, 3, 4), Vec4(2, 1, 3, 4)) == UVec4(0xffffffffU, 0, 0xffffffffU, 0xffffffffU));
CHECK(Vec4::sGreater(Vec4(1, 2, 3, 4), Vec4(2, 1, 3, 4)) == UVec4(0, 0xffffffffU, 0, 0));
CHECK(Vec4::sGreaterOrEqual(Vec4(1, 2, 3, 4), Vec4(2, 1, 3, 4)) == UVec4(0, 0xffffffffU, 0xffffffffU, 0xffffffffU));
}
TEST_CASE("TestVec4FMA")
{
CHECK(Vec4::sFusedMultiplyAdd(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), Vec4(9, 10, 11, 12)) == Vec4(1 * 5 + 9, 2 * 6 + 10, 3 * 7 + 11, 4 * 8 + 12));
}
TEST_CASE("TestVec4Select")
{
CHECK(Vec4::sSelect(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), UVec4(0x80000000U, 0, 0x80000000U, 0)) == Vec4(5, 2, 7, 4));
CHECK(Vec4::sSelect(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), UVec4(0, 0x80000000U, 0, 0x80000000U)) == Vec4(1, 6, 3, 8));
CHECK(Vec4::sSelect(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), UVec4(0xffffffffU, 0x7fffffffU, 0xffffffffU, 0x7fffffffU)) == Vec4(5, 2, 7, 4));
CHECK(Vec4::sSelect(Vec4(1, 2, 3, 4), Vec4(5, 6, 7, 8), UVec4(0x7fffffffU, 0xffffffffU, 0x7fffffffU, 0xffffffffU)) == Vec4(1, 6, 3, 8));
}
TEST_CASE("TestVec4BitOps")
{
// Test all bit permutations
Vec4 v1(UVec4(0b0011, 0b00110, 0b001100, 0b0011000).ReinterpretAsFloat());
Vec4 v2(UVec4(0b0101, 0b01010, 0b010100, 0b0101000).ReinterpretAsFloat());
CHECK(Vec4::sOr(v1, v2) == Vec4(UVec4(0b0111, 0b01110, 0b011100, 0b0111000).ReinterpretAsFloat()));
CHECK(Vec4::sXor(v1, v2) == Vec4(UVec4(0b0110, 0b01100, 0b011000, 0b0110000).ReinterpretAsFloat()));
CHECK(Vec4::sAnd(v1, v2) == Vec4(UVec4(0b0001, 0b00010, 0b000100, 0b0001000).ReinterpretAsFloat()));
}
TEST_CASE("TestVec4Close")
{
CHECK(Vec4(1, 2, 3, 4).IsClose(Vec4(1.001f, 2.001f, 3.001f, 4.001f), 1.0e-4f));
CHECK(!Vec4(1, 2, 3, 4).IsClose(Vec4(1.001f, 2.001f, 3.001f, 4.001f), 1.0e-6f));
CHECK(Vec4(1.001f, 0, 0, 0).IsNormalized(1.0e-2f));
CHECK(!Vec4(0, 1.001f, 0, 0).IsNormalized(1.0e-4f));
CHECK(Vec4(-1.0e-7f, 1.0e-7f, 1.0e-8f, -1.0e-8f).IsNearZero());
CHECK(!Vec4(-1.0e-7f, 1.0e-7f, -1.0e-5f, 1.0e-5f).IsNearZero());
}
TEST_CASE("TestVec4Operators")
{
CHECK(-Vec4(1, 2, 3, 4) == Vec4(-1, -2, -3, -4));
Vec4 neg_zero = -Vec4::sZero();
CHECK(neg_zero == Vec4::sZero());
#ifdef JPH_CROSS_PLATFORM_DETERMINISTIC
// When cross platform deterministic, we want to make sure that -0 is represented as 0
UVec4 neg_zero_bin = neg_zero.ReinterpretAsInt();
CHECK(neg_zero_bin.GetX() == 0);
CHECK(neg_zero_bin.GetY() == 0);
CHECK(neg_zero_bin.GetZ() == 0);
CHECK(neg_zero_bin.GetW() == 0);
#endif // JPH_CROSS_PLATFORM_DETERMINISTIC
CHECK(Vec4(1, 2, 3, 4) + Vec4(5, 6, 7, 8) == Vec4(6, 8, 10, 12));
CHECK(Vec4(1, 2, 3, 4) - Vec4(8, 7, 6, 5) == Vec4(-7, -5, -3, -1));
CHECK(Vec4(1, 2, 3, 4) * Vec4(5, 6, 7, 8) == Vec4(5, 12, 21, 32));
CHECK(Vec4(1, 2, 3, 4) * 2 == Vec4(2, 4, 6, 8));
CHECK(4 * Vec4(1, 2, 3, 4) == Vec4(4, 8, 12, 16));
CHECK(Vec4(1, 2, 3, 4) / 2 == Vec4(0.5f, 1.0f, 1.5f, 2.0f));
CHECK(Vec4(1, 2, 3, 4) / Vec4(2, 8, 24, 64) == Vec4(0.5f, 0.25f, 0.125f, 0.0625f));
Vec4 v = Vec4(1, 2, 3, 4);
v *= Vec4(5, 6, 7, 8);
CHECK(v == Vec4(5, 12, 21, 32));
v *= 2;
CHECK(v == Vec4(10, 24, 42, 64));
v /= 2;
CHECK(v == Vec4(5, 12, 21, 32));
v += Vec4(1, 2, 3, 4);
CHECK(v == Vec4(6, 14, 24, 36));
CHECK(Vec4(2, 4, 8, 16).Reciprocal() == Vec4(0.5f, 0.25f, 0.125f, 0.0625f));
}
TEST_CASE("TestVec4Swizzle")
{
Vec4 v(1, 2, 3, 4);
CHECK(v.SplatX() == Vec4::sReplicate(1));
CHECK(v.SplatY() == Vec4::sReplicate(2));
CHECK(v.SplatZ() == Vec4::sReplicate(3));
CHECK(v.SplatW() == Vec4::sReplicate(4));
CHECK(v.SplatX3() == Vec3::sReplicate(1));
CHECK(v.SplatY3() == Vec3::sReplicate(2));
CHECK(v.SplatZ3() == Vec3::sReplicate(3));
CHECK(v.SplatW3() == Vec3::sReplicate(4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X>() == Vec4(1, 1, 1, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_Y>() == Vec4(1, 1, 1, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_Z>() == Vec4(1, 1, 1, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_W>() == Vec4(1, 1, 1, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_X>() == Vec4(1, 1, 2, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Y>() == Vec4(1, 1, 2, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z>() == Vec4(1, 1, 2, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_W>() == Vec4(1, 1, 2, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_X>() == Vec4(1, 1, 3, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Y>() == Vec4(1, 1, 3, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Z>() == Vec4(1, 1, 3, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_W>() == Vec4(1, 1, 3, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_W, SWIZZLE_X>() == Vec4(1, 1, 4, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_W, SWIZZLE_Y>() == Vec4(1, 1, 4, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_W, SWIZZLE_Z>() == Vec4(1, 1, 4, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_X, SWIZZLE_W, SWIZZLE_W>() == Vec4(1, 1, 4, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_X>() == Vec4(1, 2, 1, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Y>() == Vec4(1, 2, 1, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Z>() == Vec4(1, 2, 1, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_W>() == Vec4(1, 2, 1, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_X>() == Vec4(1, 2, 2, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y>() == Vec4(1, 2, 2, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Z>() == Vec4(1, 2, 2, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_W>() == Vec4(1, 2, 2, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>() == Vec4(1, 2, 3, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Y>() == Vec4(1, 2, 3, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z>() == Vec4(1, 2, 3, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W>() == Vec4(1, 2, 3, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_X>() == Vec4(1, 2, 4, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Y>() == Vec4(1, 2, 4, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Z>() == Vec4(1, 2, 4, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_W>() == Vec4(1, 2, 4, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_X>() == Vec4(1, 3, 1, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y>() == Vec4(1, 3, 1, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Z>() == Vec4(1, 3, 1, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_W>() == Vec4(1, 3, 1, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_X>() == Vec4(1, 3, 2, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Y>() == Vec4(1, 3, 2, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Z>() == Vec4(1, 3, 2, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_W>() == Vec4(1, 3, 2, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_X>() == Vec4(1, 3, 3, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Y>() == Vec4(1, 3, 3, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z>() == Vec4(1, 3, 3, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_W>() == Vec4(1, 3, 3, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_X>() == Vec4(1, 3, 4, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Y>() == Vec4(1, 3, 4, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Z>() == Vec4(1, 3, 4, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W>() == Vec4(1, 3, 4, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_X, SWIZZLE_X>() == Vec4(1, 4, 1, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_X, SWIZZLE_Y>() == Vec4(1, 4, 1, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_X, SWIZZLE_Z>() == Vec4(1, 4, 1, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_X, SWIZZLE_W>() == Vec4(1, 4, 1, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_X>() == Vec4(1, 4, 2, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Y>() == Vec4(1, 4, 2, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Z>() == Vec4(1, 4, 2, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_W>() == Vec4(1, 4, 2, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_X>() == Vec4(1, 4, 3, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Y>() == Vec4(1, 4, 3, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Z>() == Vec4(1, 4, 3, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_W>() == Vec4(1, 4, 3, 4));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_W, SWIZZLE_X>() == Vec4(1, 4, 4, 1));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_W, SWIZZLE_Y>() == Vec4(1, 4, 4, 2));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_W, SWIZZLE_Z>() == Vec4(1, 4, 4, 3));
CHECK(v.Swizzle<SWIZZLE_X, SWIZZLE_W, SWIZZLE_W, SWIZZLE_W>() == Vec4(1, 4, 4, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X>() == Vec4(2, 1, 1, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_X, SWIZZLE_Y>() == Vec4(2, 1, 1, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_X, SWIZZLE_Z>() == Vec4(2, 1, 1, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_X, SWIZZLE_W>() == Vec4(2, 1, 1, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_X>() == Vec4(2, 1, 2, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Y>() == Vec4(2, 1, 2, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z>() == Vec4(2, 1, 2, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_W>() == Vec4(2, 1, 2, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_X>() == Vec4(2, 1, 3, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Y>() == Vec4(2, 1, 3, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Z>() == Vec4(2, 1, 3, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_W>() == Vec4(2, 1, 3, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_W, SWIZZLE_X>() == Vec4(2, 1, 4, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_W, SWIZZLE_Y>() == Vec4(2, 1, 4, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_W, SWIZZLE_Z>() == Vec4(2, 1, 4, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_X, SWIZZLE_W, SWIZZLE_W>() == Vec4(2, 1, 4, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_X>() == Vec4(2, 2, 1, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Y>() == Vec4(2, 2, 1, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Z>() == Vec4(2, 2, 1, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_W>() == Vec4(2, 2, 1, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_X>() == Vec4(2, 2, 2, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y>() == Vec4(2, 2, 2, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Z>() == Vec4(2, 2, 2, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_W>() == Vec4(2, 2, 2, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>() == Vec4(2, 2, 3, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Y>() == Vec4(2, 2, 3, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z>() == Vec4(2, 2, 3, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W>() == Vec4(2, 2, 3, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_X>() == Vec4(2, 2, 4, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Y>() == Vec4(2, 2, 4, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Z>() == Vec4(2, 2, 4, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_W>() == Vec4(2, 2, 4, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_X>() == Vec4(2, 3, 1, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y>() == Vec4(2, 3, 1, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Z>() == Vec4(2, 3, 1, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_W>() == Vec4(2, 3, 1, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_X>() == Vec4(2, 3, 2, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Y>() == Vec4(2, 3, 2, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Z>() == Vec4(2, 3, 2, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_W>() == Vec4(2, 3, 2, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_X>() == Vec4(2, 3, 3, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Y>() == Vec4(2, 3, 3, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z>() == Vec4(2, 3, 3, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_W>() == Vec4(2, 3, 3, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_X>() == Vec4(2, 3, 4, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Y>() == Vec4(2, 3, 4, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Z>() == Vec4(2, 3, 4, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W>() == Vec4(2, 3, 4, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_X, SWIZZLE_X>() == Vec4(2, 4, 1, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_X, SWIZZLE_Y>() == Vec4(2, 4, 1, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_X, SWIZZLE_Z>() == Vec4(2, 4, 1, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_X, SWIZZLE_W>() == Vec4(2, 4, 1, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_X>() == Vec4(2, 4, 2, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Y>() == Vec4(2, 4, 2, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Z>() == Vec4(2, 4, 2, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_W>() == Vec4(2, 4, 2, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_X>() == Vec4(2, 4, 3, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Y>() == Vec4(2, 4, 3, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Z>() == Vec4(2, 4, 3, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_W>() == Vec4(2, 4, 3, 4));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_W, SWIZZLE_X>() == Vec4(2, 4, 4, 1));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_W, SWIZZLE_Y>() == Vec4(2, 4, 4, 2));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_W, SWIZZLE_Z>() == Vec4(2, 4, 4, 3));
CHECK(v.Swizzle<SWIZZLE_Y, SWIZZLE_W, SWIZZLE_W, SWIZZLE_W>() == Vec4(2, 4, 4, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X>() == Vec4(3, 1, 1, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_X, SWIZZLE_Y>() == Vec4(3, 1, 1, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_X, SWIZZLE_Z>() == Vec4(3, 1, 1, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_X, SWIZZLE_W>() == Vec4(3, 1, 1, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_X>() == Vec4(3, 1, 2, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Y>() == Vec4(3, 1, 2, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z>() == Vec4(3, 1, 2, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_W>() == Vec4(3, 1, 2, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_X>() == Vec4(3, 1, 3, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Y>() == Vec4(3, 1, 3, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Z>() == Vec4(3, 1, 3, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_W>() == Vec4(3, 1, 3, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_W, SWIZZLE_X>() == Vec4(3, 1, 4, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_W, SWIZZLE_Y>() == Vec4(3, 1, 4, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_W, SWIZZLE_Z>() == Vec4(3, 1, 4, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_X, SWIZZLE_W, SWIZZLE_W>() == Vec4(3, 1, 4, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_X>() == Vec4(3, 2, 1, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Y>() == Vec4(3, 2, 1, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Z>() == Vec4(3, 2, 1, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_W>() == Vec4(3, 2, 1, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_X>() == Vec4(3, 2, 2, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y>() == Vec4(3, 2, 2, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Z>() == Vec4(3, 2, 2, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_W>() == Vec4(3, 2, 2, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>() == Vec4(3, 2, 3, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Y>() == Vec4(3, 2, 3, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z>() == Vec4(3, 2, 3, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W>() == Vec4(3, 2, 3, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_X>() == Vec4(3, 2, 4, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Y>() == Vec4(3, 2, 4, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Z>() == Vec4(3, 2, 4, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_W>() == Vec4(3, 2, 4, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_X>() == Vec4(3, 3, 1, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y>() == Vec4(3, 3, 1, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Z>() == Vec4(3, 3, 1, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_W>() == Vec4(3, 3, 1, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_X>() == Vec4(3, 3, 2, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Y>() == Vec4(3, 3, 2, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Z>() == Vec4(3, 3, 2, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_W>() == Vec4(3, 3, 2, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_X>() == Vec4(3, 3, 3, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Y>() == Vec4(3, 3, 3, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z>() == Vec4(3, 3, 3, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_W>() == Vec4(3, 3, 3, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_X>() == Vec4(3, 3, 4, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Y>() == Vec4(3, 3, 4, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Z>() == Vec4(3, 3, 4, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W>() == Vec4(3, 3, 4, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_X, SWIZZLE_X>() == Vec4(3, 4, 1, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_X, SWIZZLE_Y>() == Vec4(3, 4, 1, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_X, SWIZZLE_Z>() == Vec4(3, 4, 1, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_X, SWIZZLE_W>() == Vec4(3, 4, 1, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_X>() == Vec4(3, 4, 2, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Y>() == Vec4(3, 4, 2, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Z>() == Vec4(3, 4, 2, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_W>() == Vec4(3, 4, 2, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_X>() == Vec4(3, 4, 3, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Y>() == Vec4(3, 4, 3, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Z>() == Vec4(3, 4, 3, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_W>() == Vec4(3, 4, 3, 4));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W, SWIZZLE_X>() == Vec4(3, 4, 4, 1));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W, SWIZZLE_Y>() == Vec4(3, 4, 4, 2));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W, SWIZZLE_Z>() == Vec4(3, 4, 4, 3));
CHECK(v.Swizzle<SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W, SWIZZLE_W>() == Vec4(3, 4, 4, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X>() == Vec4(4, 1, 1, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_X, SWIZZLE_Y>() == Vec4(4, 1, 1, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_X, SWIZZLE_Z>() == Vec4(4, 1, 1, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_X, SWIZZLE_W>() == Vec4(4, 1, 1, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_X>() == Vec4(4, 1, 2, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Y>() == Vec4(4, 1, 2, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z>() == Vec4(4, 1, 2, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_Y, SWIZZLE_W>() == Vec4(4, 1, 2, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_X>() == Vec4(4, 1, 3, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Y>() == Vec4(4, 1, 3, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_Z>() == Vec4(4, 1, 3, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_Z, SWIZZLE_W>() == Vec4(4, 1, 3, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_W, SWIZZLE_X>() == Vec4(4, 1, 4, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_W, SWIZZLE_Y>() == Vec4(4, 1, 4, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_W, SWIZZLE_Z>() == Vec4(4, 1, 4, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_X, SWIZZLE_W, SWIZZLE_W>() == Vec4(4, 1, 4, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_X>() == Vec4(4, 2, 1, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Y>() == Vec4(4, 2, 1, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_Z>() == Vec4(4, 2, 1, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_X, SWIZZLE_W>() == Vec4(4, 2, 1, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_X>() == Vec4(4, 2, 2, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y>() == Vec4(4, 2, 2, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Z>() == Vec4(4, 2, 2, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_W>() == Vec4(4, 2, 2, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_X>() == Vec4(4, 2, 3, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Y>() == Vec4(4, 2, 3, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z>() == Vec4(4, 2, 3, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W>() == Vec4(4, 2, 3, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_X>() == Vec4(4, 2, 4, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Y>() == Vec4(4, 2, 4, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_Z>() == Vec4(4, 2, 4, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Y, SWIZZLE_W, SWIZZLE_W>() == Vec4(4, 2, 4, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_X>() == Vec4(4, 3, 1, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Y>() == Vec4(4, 3, 1, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_Z>() == Vec4(4, 3, 1, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_X, SWIZZLE_W>() == Vec4(4, 3, 1, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_X>() == Vec4(4, 3, 2, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Y>() == Vec4(4, 3, 2, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_Z>() == Vec4(4, 3, 2, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Y, SWIZZLE_W>() == Vec4(4, 3, 2, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_X>() == Vec4(4, 3, 3, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Y>() == Vec4(4, 3, 3, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_Z>() == Vec4(4, 3, 3, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Z, SWIZZLE_W>() == Vec4(4, 3, 3, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_X>() == Vec4(4, 3, 4, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Y>() == Vec4(4, 3, 4, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Z>() == Vec4(4, 3, 4, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W>() == Vec4(4, 3, 4, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_X, SWIZZLE_X>() == Vec4(4, 4, 1, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_X, SWIZZLE_Y>() == Vec4(4, 4, 1, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_X, SWIZZLE_Z>() == Vec4(4, 4, 1, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_X, SWIZZLE_W>() == Vec4(4, 4, 1, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_X>() == Vec4(4, 4, 2, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Y>() == Vec4(4, 4, 2, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_Z>() == Vec4(4, 4, 2, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_Y, SWIZZLE_W>() == Vec4(4, 4, 2, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_X>() == Vec4(4, 4, 3, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Y>() == Vec4(4, 4, 3, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_Z>() == Vec4(4, 4, 3, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_W>() == Vec4(4, 4, 3, 4));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_W, SWIZZLE_X>() == Vec4(4, 4, 4, 1));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_W, SWIZZLE_Y>() == Vec4(4, 4, 4, 2));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_W, SWIZZLE_Z>() == Vec4(4, 4, 4, 3));
CHECK(v.Swizzle<SWIZZLE_W, SWIZZLE_W, SWIZZLE_W, SWIZZLE_W>() == Vec4(4, 4, 4, 4));
}
TEST_CASE("TestVec4Abs")
{
CHECK(Vec4(1, -2, 3, -4).Abs() == Vec4(1, 2, 3, 4));
CHECK(Vec4(-1, 2, -3, 4).Abs() == Vec4(1, 2, 3, 4));
}
TEST_CASE("TestVec4Dot")
{
CHECK(Vec4(1, 2, 3, 4).Dot(Vec4(5, 6, 7, 8)) == float(1 * 5 + 2 * 6 + 3 * 7 + 4 * 8));
CHECK(Vec4(1, 2, 3, 4).DotV(Vec4(5, 6, 7, 8)) == Vec4::sReplicate(1 * 5 + 2 * 6 + 3 * 7 + 4 * 8));
}
TEST_CASE("TestVec4Length")
{
CHECK(Vec4(1, 2, 3, 4).LengthSq() == float(1 + 4 + 9 + 16));
CHECK(Vec4(1, 2, 3, 4).Length() == sqrt(float(1 + 4 + 9 + 16)));
}
TEST_CASE("TestVec4Sqrt")
{
CHECK_APPROX_EQUAL(Vec4(13, 15, 17, 19).Sqrt(), Vec4(sqrt(13.0f), sqrt(15.0f), sqrt(17.0f), sqrt(19.0f)));
}
TEST_CASE("TestVec4Normalize")
{
CHECK(Vec4(1, 2, 3, 4).Normalized() == Vec4(1, 2, 3, 4) / sqrt(30.0f));
}
TEST_CASE("TestVec4Cast")
{
CHECK(Vec4(1, 2, 3, 4).ToInt() == UVec4(1, 2, 3, 4));
CHECK(Vec4(1, 2, 3, 4).ReinterpretAsInt() == UVec4(0x3f800000U, 0x40000000U, 0x40400000U, 0x40800000U));
}
TEST_CASE("TestVec4Sign")
{
CHECK(Vec4(1.2345f, -6.7891f, 0, 1).GetSign() == Vec4(1, -1, 1, 1));
CHECK(Vec4(0, 2.3456f, -7.8912f, -1).GetSign() == Vec4(1, 1, -1, -1));
}
TEST_CASE("TestVec4FlipSign")
{
Vec4 v(1, 2, 3, 4);
CHECK(v.FlipSign<-1, 1, 1, 1>() == Vec4(-1, 2, 3, 4));
CHECK(v.FlipSign<1, -1, 1, 1>() == Vec4(1, -2, 3, 4));
CHECK(v.FlipSign<1, 1, -1, 1>() == Vec4(1, 2, -3, 4));
CHECK(v.FlipSign<1, 1, 1, -1>() == Vec4(1, 2, 3, -4));
}
TEST_CASE("TestVec4SignBit")
{
CHECK(Vec4(2, -3, 4, -5).GetSignBits() == 0b1010);
CHECK(Vec4(-2, 3, -4, 5).GetSignBits() == 0b0101);
}
TEST_CASE("TestVec4Sort")
{
for (int i = 0; i < 4; ++i)
for (int j = 0; j < 4; ++j)
if (i != j)
for (int k = 0; k < 4; ++k)
if (i != k && j != k)
for (int l = 0; l < 4; ++l)
if (i != l && j != l && k != l)
{
Vec4 v1((float)i, (float)j, (float)k, (float)l);
Vec4 v2 = v1;
UVec4 idx1 = UVec4(i + 4, j + 4, k + 4, l + 4);
UVec4 idx2 = idx1;
Vec4::sSort4(v1, idx1);
Vec4::sSort4Reverse(v2, idx2);
for (int m = 0; m < 4; ++m)
{
CHECK(v1[m] == float(m));
CHECK(v2[m] == float(3 - m));
CHECK(idx1[m] == uint32(m + 4));
CHECK(idx2[m] == uint32(3 - m + 4));
}
}
}
TEST_CASE("TestVec4SinCos")
{
// Check edge cases
Vec4 vs, vc;
Vec4(0, 0.5f * JPH_PI, JPH_PI, -0.5f * JPH_PI).SinCos(vs, vc);
CHECK(vs.IsClose(Vec4(0, 1, 0, -1), 1.0e-7f));
CHECK(vc.IsClose(Vec4(1, 0, -1, 0), 1.0e-7f));
double ms = 0.0, mc = 0.0;
for (float x = -100.0f * JPH_PI; x < 100.0f * JPH_PI; x += 1.0e-3f)
{
// Create a vector with intermediate values
Vec4 xv = Vec4::sReplicate(x) + Vec4(0.0e-4f, 2.5e-4f, 5.0e-4f, 7.5e-4f);
// Calculate sin and cos
xv.SinCos(vs, vc);
for (int i = 0; i < 4; ++i)
{
// Check accuracy of sin
double s1 = sin((double)xv[i]), s2 = (double)vs[i];
double ds = abs(s2 - s1);
ms = max(ms, ds);
// Check accuracy of cos
double c1 = cos((double)xv[i]), c2 = (double)vc[i];
double dc = abs(c2 - c1);
mc = max(mc, dc);
}
}
CHECK(ms < 1.0e-7);
CHECK(mc < 1.0e-7);
}
TEST_CASE("TestVec4Tan")
{
// Check edge cases
CHECK(Vec4::sReplicate(0.0f).Tan() == Vec4::sZero());
CHECK(Vec4::sReplicate(0.5f * JPH_PI - 1.0e-6f).Tan().GetX() > 1.0e6f);
CHECK(Vec4::sReplicate(0.5f * JPH_PI + 1.0e-6f).Tan().GetX() < -1.0e6f);
double mt = 0.0;
for (float x = -100.0f * JPH_PI; x < 100.0f * JPH_PI; x += 1.0e-3f)
{
// Create a vector with intermediate values
Vec4 xv = Vec4::sReplicate(x) + Vec4(0.0e-4f, 2.5e-4f, 5.0e-4f, 7.5e-4f);
// Calculate tan
Vec4 vt = xv.Tan();
for (int i = 0; i < 4; ++i)
{
// Check accuracy of tan
double t1 = tan((double)xv[i]), t2 = (double)vt[i];
double dt = abs(t2 - t1);
mt = max(mt, dt) / max(1.0, abs(t1)); // Take relative error
}
}
CHECK(mt < 1.5e-7);
}
TEST_CASE("TestVec4ASin")
{
// Check edge cases
CHECK(Vec4::sReplicate(0.0f).ASin() == Vec4::sZero());
CHECK(Vec4::sOne().ASin() == Vec4::sReplicate(0.5f * JPH_PI));
CHECK(Vec4::sReplicate(-1.0f).ASin() == Vec4::sReplicate(-0.5f * JPH_PI));
double ma = 0.0;
for (float x = -1.0f; x <= 1.0f; x += 1.0e-3f)
{
// Create a vector with intermediate values
Vec4 xv = Vec4::sMin(Vec4::sReplicate(x) + Vec4(0.0e-4f, 2.5e-4f, 5.0e-4f, 7.5e-4f), Vec4::sOne());
// Calculate asin
Vec4 va = xv.ASin();
for (int i = 0; i < 4; ++i)
{
// Check accuracy of asin
double a1 = asin((double)xv[i]), a2 = (double)va[i];
double da = abs(a2 - a1);
ma = max(ma, da);
}
}
CHECK(ma < 2.0e-7);
// Check that inputs are clamped as promised
CHECK(Vec4::sReplicate(-1.1f).ASin() == Vec4::sReplicate(-0.5f * JPH_PI));
CHECK(Vec4::sReplicate(1.1f).ASin() == Vec4::sReplicate(0.5f * JPH_PI));
}
TEST_CASE("TestVec4ACos")
{
// Check edge cases
CHECK(Vec4::sReplicate(0.0f).ACos() == Vec4::sReplicate(0.5f * JPH_PI));
CHECK(Vec4::sOne().ACos() == Vec4::sZero());
CHECK(Vec4::sReplicate(-1.0f).ACos() == Vec4::sReplicate(JPH_PI));
double ma = 0.0;
for (float x = -1.0f; x <= 1.0f; x += 1.0e-3f)
{
// Create a vector with intermediate values
Vec4 xv = Vec4::sMin(Vec4::sReplicate(x) + Vec4(0.0e-4f, 2.5e-4f, 5.0e-4f, 7.5e-4f), Vec4::sOne());
// Calculate acos
Vec4 va = xv.ACos();
for (int i = 0; i < 4; ++i)
{
// Check accuracy of acos
double a1 = acos((double)xv[i]), a2 = (double)va[i];
double da = abs(a2 - a1);
ma = max(ma, da);
}
}
CHECK(ma < 3.5e-7);
// Check that inputs are clamped as promised
CHECK(Vec4::sReplicate(-1.1f).ACos() == Vec4::sReplicate(JPH_PI));
CHECK(Vec4::sReplicate(1.1f).ACos() == Vec4::sZero());
}
TEST_CASE("TestVec4ATan")
{
// Check edge cases
CHECK(Vec4::sReplicate(0.0f).ATan() == Vec4::sZero());
CHECK(Vec4::sReplicate(FLT_MAX).ATan() == Vec4::sReplicate(0.5f * JPH_PI));
CHECK(Vec4::sReplicate(-FLT_MAX).ATan() == Vec4::sReplicate(-0.5f * JPH_PI));
double ma = 0.0;
for (float x = -100.0f; x < 100.0f; x += 1.0e-3f)
{
// Create a vector with intermediate values
Vec4 xv = Vec4::sReplicate(x) + Vec4(0.0e-4f, 2.5e-4f, 5.0e-4f, 7.5e-4f);
// Calculate atan
Vec4 va = xv.ATan();
for (int i = 0; i < 4; ++i)
{
// Check accuracy of atan
double a1 = atan((double)xv[i]), a2 = (double)va[i];
double da = abs(a2 - a1);
ma = max(ma, da);
}
}
CHECK(ma < 1.5e-7);
}
TEST_CASE("TestVec4ATan2")
{
double ma = 0.0;
// Test the axis
CHECK(Vec4::sATan2(Vec4::sZero(), Vec4::sReplicate(10.0f)) == Vec4::sZero());
CHECK(Vec4::sATan2(Vec4::sZero(), Vec4::sReplicate(-10.0f)) == Vec4::sReplicate(JPH_PI));
CHECK(Vec4::sATan2(Vec4::sReplicate(10.0f), Vec4::sZero()) == Vec4::sReplicate(0.5f * JPH_PI));
CHECK(Vec4::sATan2(Vec4::sReplicate(-10.0f), Vec4::sZero()) == Vec4::sReplicate(-0.5f * JPH_PI));
// Test the 4 quadrants
CHECK(Vec4::sATan2(Vec4::sReplicate(10.0f), Vec4::sReplicate(10.0f)) == Vec4::sReplicate(0.25f * JPH_PI));
CHECK(Vec4::sATan2(Vec4::sReplicate(10.0f), Vec4::sReplicate(-10.0f)) == Vec4::sReplicate(0.75f * JPH_PI));
CHECK(Vec4::sATan2(Vec4::sReplicate(-10.0f), Vec4::sReplicate(-10.0f)) == Vec4::sReplicate(-0.75f * JPH_PI));
CHECK(Vec4::sATan2(Vec4::sReplicate(-10.0f), Vec4::sReplicate(10.0f)) == Vec4::sReplicate(-0.25f * JPH_PI));
for (float y = -5.0f; y < 5.0f; y += 1.0e-2f)
{
// Create a vector with intermediate values
Vec4 yv = Vec4::sReplicate(y) + Vec4(0.0e-3f, 2.5e-3f, 5.0e-3f, 7.5e-3f);
for (float x = -5.0f; x < 5.0f; x += 1.0e-2f)
{
// Create a vector with intermediate values
Vec4 xv = Vec4::sReplicate(x) + Vec4(0.0e-3f, 2.5e-3f, 5.0e-3f, 7.5e-3f);
// Calculate atan
Vec4 va = Vec4::sATan2(yv, xv);
for (int i = 0; i < 4; ++i)
{
// Check accuracy of atan
double a1 = atan2((double)yv[i], (double)xv[i]), a2 = (double)va[i];
double da = abs(a2 - a1);
ma = max(ma, da);
}
}
}
CHECK(ma < 3.0e-7);
}
TEST_CASE("TestVec4ConvertToString")
{
Vec4 v(1, 2, 3, 4);
CHECK(ConvertToString(v) == "1, 2, 3, 4");
}
TEST_CASE("TestVec4CompressUnitVector")
{
// We want these to be preserved exactly
CHECK(Vec4::sDecompressUnitVector(Vec4(1, 0, 0, 0).CompressUnitVector()) == Vec4(1, 0, 0, 0));
CHECK(Vec4::sDecompressUnitVector(Vec4(0, 1, 0, 0).CompressUnitVector()) == Vec4(0, 1, 0, 0));
CHECK(Vec4::sDecompressUnitVector(Vec4(0, 0, 1, 0).CompressUnitVector()) == Vec4(0, 0, 1, 0));
CHECK(Vec4::sDecompressUnitVector(Vec4(0, 0, 0, 1).CompressUnitVector()) == Vec4(0, 0, 0, 1));
CHECK(Vec4::sDecompressUnitVector(Vec4(-1, 0, 0, 0).CompressUnitVector()) == Vec4(-1, 0, 0, 0));
CHECK(Vec4::sDecompressUnitVector(Vec4(0, -1, 0, 0).CompressUnitVector()) == Vec4(0, -1, 0, 0));
CHECK(Vec4::sDecompressUnitVector(Vec4(0, 0, -1, 0).CompressUnitVector()) == Vec4(0, 0, -1, 0));
CHECK(Vec4::sDecompressUnitVector(Vec4(0, 0, 0, -1).CompressUnitVector()) == Vec4(0, 0, 0, -1));
UnitTestRandom random;
for (int i = 0; i < 1000; ++i)
{
std::uniform_real_distribution<float> scale(-1.0f, 1.0f);
Vec4 v = Vec4(scale(random), scale(random), scale(random), scale(random)).Normalized();
uint32 compressed = v.CompressUnitVector();
Vec4 decompressed = Vec4::sDecompressUnitVector(compressed);
float diff = (decompressed - v).Length();
CHECK(diff < 5.0e-3f);
}
}
}

102
lib/All/JoltPhysics/UnitTests/Math/VectorTests.cpp Normal file
View File

@@ -0,0 +1,102 @@
// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
#include "UnitTestFramework.h"
#include <Jolt/Math/Vector.h>
TEST_SUITE("VectorTests")
{
TEST_CASE("TestVectorEquals")
{
Vector<3> v1;
v1[0] = 1;
v1[1] = 2;
v1[2] = 3;
Vector<3> v2;
v2[0] = 1;
v2[1] = 2;
v2[2] = 3;
Vector<3> v3;
v3[0] = 1;
v3[1] = 5;
v3[2] = 3;
CHECK(v1 == v2);
CHECK(!(v1 != v2));
CHECK(v1 != v3);
CHECK(!(v1 == v3));
}
TEST_CASE("TestVectorStream")
{
Vector<3> v1;
v1[0] = 1;
v1[1] = 2;
v1[2] = 3;
std::stringstream ss;
ss << v1;
CHECK(ss.str() == "[1, 2, 3]");
}
TEST_CASE("TestVectorMultiplyFloat")
{
Vector<5> v;
v[0] = 1;
v[1] = 2;
v[2] = 3;
v[3] = 4;
v[4] = 5;
Vector<5> v2 = v * 2;
CHECK(v2[0] == 2.0f);
CHECK(v2[1] == 4.0f);
CHECK(v2[2] == 6.0f);
CHECK(v2[3] == 8.0f);
CHECK(v2[4] == 10.0f);
}
TEST_CASE("TestVectorAdd")
{
Vector<5> v1 = Vector<5>::sZero();
Vector<5> v2 = Vector<5>::sZero();
v1[0] = 1;
v2[0] = 2;
v1[4] = 5;
Vector<5> v3 = v1 + v2;
CHECK(v3[0] == 3.0f);
CHECK(v3[1] == 0.0f);
CHECK(v3[2] == 0.0f);
CHECK(v3[3] == 0.0f);
CHECK(v3[4] == 5.0f);
}
TEST_CASE("TestVectorNegate")
{
Vector<5> v;
v[0] = 1;
v[1] = 2;
v[2] = 3;
v[3] = 4;
v[4] = 5;
Vector<5> v2 = -v;
CHECK(v2[0] == -1.0f);
CHECK(v2[1] == -2.0f);
CHECK(v2[2] == -3.0f);
CHECK(v2[3] == -4.0f);
CHECK(v2[4] == -5.0f);
}
TEST_CASE("TestVectorLength")
{
Vector<5> v;
v[0] = 1;
v[1] = 2;
v[2] = 3;
v[3] = 4;
v[4] = 5;
CHECK(v.LengthSq() == float(1 + 4 + 9 + 16 + 25));
}
}