birkeh/o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Removed MCore::Quaternion AZ::Quaternion comparison tests

Browse Source 
Signed-off-by: Benjamin Jillich <jillich@amazon.com>
This commit is contained in:
Benjamin Jillich
2021-07-29 14:41:55 +02:00
parent aa98be18b7
commit cd25dbf71f
11 changed files with 7 additions and 420 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Gems/EMotionFX/Code/EMotionFX/Rendering/Common/OrthographicCamera.cpp
+1
View File
@@ -7,6 +7,7 @@
*/
#include "OrthographicCamera.h"
#include <MCore/Source/AABB.h>
#include <MCore/Source/Compare.h>
#include <MCore/Source/Distance.h>
#include <EMotionFX/Source/EMotionFXManager.h>
Gems/EMotionFX/Code/EMotionFX/Rendering/Common/ScaleManipulator.cpp
+1 -1
View File
@@ -7,7 +7,7 @@
*/
#include "ScaleManipulator.h"
#include <MCore/Source/PlaneEq.h>
namespace MCommon
{
Gems/EMotionFX/Code/EMotionFX/Rendering/Common/TranslateManipulator.cpp
+1 -1
View File
@@ -7,7 +7,7 @@
*/
#include "TranslateManipulator.h"
#include <MCore/Source/PlaneEq.h>
namespace MCommon
{
Gems/EMotionFX/Code/EMotionFX/Rendering/OpenGL2/Source/GLSLShader.cpp
+1
View File
@@ -7,6 +7,7 @@
*/
#include <MCore/Source/Config.h>
#include <MCore/Source/LogManager.h>
#include "GLSLShader.h"
#include "GraphicsManager.h"
#include <QFile>
Gems/EMotionFX/Code/EMotionFX/Source/Actor.cpp
+1
View File
@@ -41,6 +41,7 @@
#include <MCore/Source/IDGenerator.h>
#include <MCore/Source/Compare.h>
#include <MCore/Source/LogManager.h>
#include <MCore/Source/OBB.h>
#include <Atom/RPI.Reflect/Model/MorphTargetDelta.h>
Gems/EMotionFX/Code/EMotionFX/Source/Importer/ChunkProcessors.cpp
+1
View File
@@ -24,6 +24,7 @@
#include <MCore/Source/AzCoreConversions.h>
#include <MCore/Source/Distance.h>
#include <MCore/Source/File.h>
#include <MCore/Source/LogManager.h>
#include <MCore/Source/ReflectionSerializer.h>
#include <MCore/Source/StringConversions.h>
#include <MCore/Source/MCoreSystem.h>
Gems/EMotionFX/Code/MCore/Source/AzCoreConversions.h
-1
View File
@@ -18,7 +18,6 @@
#include <MCore/Source/Algorithms.h>
#include <MCore/Source/Color.h>
#include <MCore/Source/Vector.h>
#include <MCore/Source/Quaternion.h>
#include <EMotionFX/Source/Transform.h>
// This file is "glue" code to convert math back-forward between MCore and AZ. It also has functions that MCore used to
Gems/EMotionFX/Code/Tests/EmotionFXMathLibTests.cpp
-367
View File
@@ -12,7 +12,6 @@
#include <AzCore/Math/Matrix4x4.h>
#include <AzCore/Math/MathUtils.h>
#include <MCore/Source/Quaternion.h>
#include <MCore/Source/Vector.h>
#include <MCore/Source/AzCoreConversions.h>
@@ -25,7 +24,6 @@ protected:
{
m_azNormalizedVector3_a = AZ::Vector3(s_x1, s_y1, s_z1);
m_azNormalizedVector3_a.Normalize();
m_emQuaternion_a = MCore::Quaternion(m_azNormalizedVector3_a, s_angle_a);
m_azQuaternion_a = AZ::Quaternion::CreateFromAxisAngle(m_azNormalizedVector3_a, s_angle_a);
}
@@ -55,26 +53,6 @@ protected:
return true;
}
bool EmfxQuaternionCompareExact(MCore::Quaternion& quaternion, float x, float y, float z, float w)
{
if (quaternion.x != x)
{
return false;
}
if (quaternion.y != y)
{
return false;
}
if (quaternion.z != z)
{
return false;
}
if (quaternion.w != w)
{
return false;
}
return true;
}
bool AZQuaternionCompareClose(AZ::Quaternion& quaternion, float x, float y, float z, float w, float tolerance)
{
@@ -131,26 +109,6 @@ protected:
return true;
}
bool AZEMQuaternionsAreEqual(AZ::Quaternion& azQuaternion, const MCore::Quaternion& emQuaternion)
{
if (AZQuaternionCompareExact(azQuaternion, emQuaternion.x, emQuaternion.y,
emQuaternion.z, emQuaternion.w))
{
return true;
}
return false;
}
bool AZEMQuaternionsAreClose(AZ::Quaternion& azQuaternion, const MCore::Quaternion& emQuaternion, const float tolerance)
{
if (AZQuaternionCompareClose(azQuaternion, emQuaternion.x, emQuaternion.y,
emQuaternion.z, emQuaternion.w, tolerance))
{
return true;
}
return false;
}
static const float s_toleranceHigh;
static const float s_toleranceMedium;
static const float s_toleranceLow;
@@ -161,7 +119,6 @@ protected:
static const float s_angle_a;
AZ::Vector3 m_azNormalizedVector3_a;
AZ::Quaternion m_azQuaternion_a;
MCore::Quaternion m_emQuaternion_a;
};
const float EmotionFXMathLibTests::s_toleranceHigh = 0.00001f;
@@ -174,18 +131,6 @@ const float EmotionFXMathLibTests::s_y1 = 0.3f;
const float EmotionFXMathLibTests::s_z1 = 0.4f;
const float EmotionFXMathLibTests::s_angle_a = 0.5f;
///////////////////////////////////////////////////////////////////////////////
// MCore::Quaternion: Test identity values
TEST_F(EmotionFXMathLibTests, QuaternionIdentity_Identity_Success)
{
MCore::Quaternion test(0.1f, 0.2f, 0.3f, 0.4f);
test.Identity();
ASSERT_TRUE(test == MCore::Quaternion(0.0f, 0.0f, 0.0f, 1.0f));
}
//////////////////////////////////////////////////////////////////
//Getting and setting of Quaternions
//////////////////////////////////////////////////////////////////
@@ -196,52 +141,6 @@ TEST_F(EmotionFXMathLibTests, AZQuaternionGet_Elements_Success)
ASSERT_TRUE(AZQuaternionCompareExact(test, 0.1f, 0.2f, 0.3f, 0.4f));
}
// Compare equivalent normalized quaternions between systems
TEST_F(EmotionFXMathLibTests, AZEMQuaternionNormalizeEquivalent_Success)
{
AZ::Quaternion azTest(0.1f, 0.2f, 0.3f, 0.4f);
MCore::Quaternion emTest(0.1f, 0.2f, 0.3f, 0.4f);
azTest.Normalize();
emTest.Normalize();
ASSERT_TRUE(AZQuaternionCompareClose(azTest, emTest.x, emTest.y, emTest.z, emTest.w, s_toleranceMedium));
}
///////////////////////////////////////////////////////////////////////////////
// Axis Angle
///////////////////////////////////////////////////////////////////////////////
// Compare setting a quaternion using axis and angle
TEST_F(EmotionFXMathLibTests, AZEMQuaternionConversion_SetToAxisAngleEquivalent_Success)
{
MCore::Quaternion emQuaternion(m_azNormalizedVector3_a, s_angle_a);
AZ::Quaternion azQuaternion = AZ::Quaternion::CreateFromAxisAngle(m_azNormalizedVector3_a, s_angle_a);
ASSERT_TRUE(AZQuaternionCompareClose(azQuaternion, emQuaternion.x, emQuaternion.y, emQuaternion.z, emQuaternion.w, s_toleranceLow));
}
// Compare equivalent conversions quaternions -> (axis, angle) between systems
TEST_F(EmotionFXMathLibTests, AZEMQuaternionConversion_ToAxisAngleEquivalent_Success)
{
//populate Quaternions with same data
MCore::Quaternion emTest = m_emQuaternion_a;
AZ::Quaternion azTest(emTest.x, emTest.y, emTest.z, emTest.w);
AZ::Vector3 emAxis;
float emAngle;
emTest.ToAxisAngle(&emAxis, &emAngle);
AZ::Vector3 azAxis;
float azAngle;
AZ::ConvertQuaternionToAxisAngle(azTest, azAxis, azAngle);
bool same = AZ::IsClose(azAngle, emAngle, s_toleranceLow) &&
AZVector3CompareClose(azAxis, emAxis, s_toleranceLow);
ASSERT_TRUE(same);
}
///////////////////////////////////////////////////////////////////////////////
//Basic rotations
///////////////////////////////////////////////////////////////////////////////
@@ -420,18 +319,6 @@ TEST_F(EmotionFXMathLibTests, AZQuaternion_EulerGetSet3ComponentAxisCompareTrans
ASSERT_TRUE(same);
}
// EM Quaternion to Euler test
TEST_F(EmotionFXMathLibTests, EMQuaternionConversion_ToEulerEquivalent_Success)
{
AZ::Vector3 eulerIn(0.1f, 0.2f, 0.3f);
MCore::Quaternion test;
test.SetEuler(eulerIn.GetX(), eulerIn.GetY(), eulerIn.GetZ());
AZ::Vector3 eulerOut = test.ToEuler();
ASSERT_TRUE(AZVector3CompareClose(eulerOut, 0.1f, 0.2f, 0.3f, s_toleranceHigh));
}
// AZ Quaternion to Euler test
//only way to test Quaternions sameness is to apply it to a vector and measure result
TEST_F(EmotionFXMathLibTests, AZQuaternionConversion_ToEulerEquivalent_Success)
@@ -456,41 +343,6 @@ TEST_F(EmotionFXMathLibTests, AZQuaternionConversion_ToEulerEquivalent_Success)
ASSERT_TRUE(AZVector3CompareClose(eulerOut1, eulerOut2, s_toleranceReallyLow));
}
///////////////////////////////////////////////////////////////////////////////
//Quaternion order test
//determines that ordering is same between systems.
///////////////////////////////////////////////////////////////////////////////
TEST_F(EmotionFXMathLibTests, AZEMQuaternion_OrderTest_Success)
{
AZ::Vector3 axis = AZ::Vector3(1.0f, 0.7f, 0.3f);
axis.Normalize();
AZ::Quaternion azQuaternion1 = AZ::Quaternion::CreateFromAxisAngle(axis, AZ::Constants::HalfPi);
AZ::Vector3 axis2 = AZ::Vector3(0.2f, 0.5f, 0.9f);
axis2.Normalize();
AZ::Quaternion azQuaternion2 = AZ::Quaternion::CreateFromAxisAngle(axis2, AZ::Constants::HalfPi);
MCore::Quaternion emQuaternion1(azQuaternion1.GetX(), azQuaternion1.GetY(), azQuaternion1.GetZ(), azQuaternion1.GetW());
MCore::Quaternion emQuaternion2(azQuaternion2.GetX(), azQuaternion2.GetY(), azQuaternion2.GetZ(), azQuaternion2.GetW());
AZ::Quaternion azQuaterionOut = azQuaternion1 * azQuaternion2;
AZ::Quaternion azQuaterionOut2 = azQuaternion2 * azQuaternion1;
MCore::Quaternion emQuaterionOut = emQuaternion1 * emQuaternion2;
AZ::Vector3 azVertexIn(0.1f, 0.2f, 0.3f);
AZ::Vector3 azVertexOut, azVertexOut2;
AZ::Vector3 emVertexOut;
azVertexOut = azQuaterionOut.TransformVector(azVertexIn);
azVertexOut2 = azQuaterionOut2.TransformVector(azVertexIn);
emVertexOut = emQuaterionOut * azVertexIn;
bool same = AZVector3CompareClose(emVertexOut, azVertexOut.GetX(), azVertexOut.GetY(), azVertexOut.GetZ(), s_toleranceMedium);
ASSERT_TRUE(same);
}
///////////////////////////////////////////////////////////////////////////////
// Quaternion Matrix
///////////////////////////////////////////////////////////////////////////////
@@ -616,225 +468,6 @@ TEST_F(EmotionFXMathLibTests, AZQuaternionConversion_ToMatrix_Success)
ASSERT_TRUE(AZ::IsClose(azMatrix.GetElement(3, 3), 1.0f, s_toleranceReallyLow));
}
///////////////////////////////////////////////////////////////////////////////
// AZEMQuaternion Compare Output tests
// Determines the AZ and MCore quaternion outputs are same/close after same math operations.
///////////////////////////////////////////////////////////////////////////////
TEST_F(EmotionFXMathLibTests, AZEMQuaternion_CompareOperatorAddEquivalent_Success)
{
// Quaternion test: operator '+' and operator '+='
AZ::Quaternion azQuaternion = AZ::Quaternion(0.1f, 0.2f, 0.3f, 1.0f);
AZ::Quaternion azQuaternion2 = AZ::Quaternion(0.8f, 0.7f, 0.6f, 1.0f);
azQuaternion.Normalize();
azQuaternion2.Normalize();
azQuaternion = azQuaternion + azQuaternion2;
azQuaternion2 += azQuaternion;
MCore::Quaternion emQuaternion = MCore::Quaternion(0.1f, 0.2f, 0.3f, 1.0f);
MCore::Quaternion emQuaternion2 = MCore::Quaternion(0.8f, 0.7f, 0.6f, 1.0f);
emQuaternion.Normalize();
emQuaternion2.Normalize();
emQuaternion = emQuaternion + emQuaternion2;
emQuaternion2 += emQuaternion;
EXPECT_TRUE(AZEMQuaternionsAreClose(azQuaternion, emQuaternion, s_toleranceLow)) << "AZ/MCore Quaternions should have similar output with operator '+'";
EXPECT_TRUE(AZEMQuaternionsAreClose(azQuaternion2, emQuaternion2, s_toleranceLow)) << "AZ/MCore Quaternions should have similar output with operator '+='";
}
TEST_F(EmotionFXMathLibTests, AZEMQuaternion_CompareOperatorSubtractEquivalent_Success)
{
// Quaternion test: operator '-' and operator '-='
AZ::Quaternion azQuaternion = AZ::Quaternion(0.1f, 0.2f, 0.3f, 1.0f);
AZ::Quaternion azQuaternion2 = AZ::Quaternion(0.8f, 0.7f, 0.6f, 1.0f);
azQuaternion.Normalize();
azQuaternion2.Normalize();
azQuaternion = azQuaternion - azQuaternion2;
azQuaternion2 -= azQuaternion;
MCore::Quaternion emQuaternion = MCore::Quaternion(0.1f, 0.2f, 0.3f, 1.0f);
MCore::Quaternion emQuaternion2 = MCore::Quaternion(0.8f, 0.7f, 0.6f, 1.0f);
emQuaternion.Normalize();
emQuaternion2.Normalize();
emQuaternion = emQuaternion - emQuaternion2;
emQuaternion2 -= emQuaternion;
EXPECT_TRUE(AZEMQuaternionsAreClose(azQuaternion, emQuaternion, s_toleranceLow)) << "AZ/MCore Quaternions should have similar output with operator '-'";
EXPECT_TRUE(AZEMQuaternionsAreClose(azQuaternion2, emQuaternion2, s_toleranceLow)) << "AZ/MCore Quaternions should have similar output with operator '-='";
}
TEST_F(EmotionFXMathLibTests, AZEMQuaternion_CompareOperatorMultiplyHasSimilarOutput_Success)
{
// Quaternion test: operator '*' and operator '*=' with another quaternion, vector3 and float
AZ::Quaternion azQuaternion = AZ::Quaternion(0.1f, 0.2f, 0.3f, 1.0f);
AZ::Quaternion azQuaternion2 = AZ::Quaternion(0.8f, 0.7f, 0.6f, 1.0f);
AZ::Quaternion azQuaternion3 = AZ::Quaternion(0.1f, 0.2f, 0.3f, 1.0f);
azQuaternion.Normalize();
azQuaternion2.Normalize();
azQuaternion3.Normalize();
azQuaternion = azQuaternion * azQuaternion2;
azQuaternion2 *= azQuaternion;
azQuaternion3 *= 0.5f;
AZ::Vector3 aztestVec3 = azQuaternion2.TransformVector(m_azNormalizedVector3_a);
MCore::Quaternion emQuaternion = MCore::Quaternion(0.1f, 0.2f, 0.3f, 1.0f);
MCore::Quaternion emQuaternion2 = MCore::Quaternion(0.8f, 0.7f, 0.6f, 1.0f);
MCore::Quaternion emQuaternion3 = MCore::Quaternion(0.1f, 0.2f, 0.3f, 1.0f);
emQuaternion.Normalize();
emQuaternion2.Normalize();
emQuaternion3.Normalize();
emQuaternion = emQuaternion * emQuaternion2;
emQuaternion2 *= emQuaternion;
emQuaternion3 *= 0.5f;
AZ::Vector3 emtestVec3 = emQuaternion2 * m_azNormalizedVector3_a;
EXPECT_TRUE(AZEMQuaternionsAreClose(azQuaternion, emQuaternion, s_toleranceLow)) << "AZ/MCore Quaternions should have similar output with operator '*' with another quaternion";
EXPECT_TRUE(AZEMQuaternionsAreClose(azQuaternion2, emQuaternion2, s_toleranceLow)) << "AZ/MCore Quaternions should have similar output with operator '*=' with another quaternion";
EXPECT_TRUE(AZEMQuaternionsAreClose(azQuaternion3, emQuaternion3, s_toleranceLow)) << "AZ/MCore Quaternions should have similar output with operator '*=' with a float value";
EXPECT_TRUE(AZVector3CompareClose(aztestVec3, emtestVec3, s_toleranceLow)) << "AZ/MCore Quaternions should have similar output with operator '*' with a vector3";
}
TEST_F(EmotionFXMathLibTests, AZEMQuaternion_EquivalentOperatorsHasSameOutput_Success)
{
// Testing Quaternion == Quaternion and operator!=
bool azCheck = AZ::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).GetNormalized() == AZ::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).GetNormalized();
bool azCheck2 = AZ::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).GetNormalized() == AZ::Quaternion(0.1000001f, 0.2000001f, 0.3000001f, 1.0f).GetNormalized();
bool azCheck3 = AZ::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).GetNormalized() != AZ::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).GetNormalized();
bool azCheck4 = AZ::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).GetNormalized() != AZ::Quaternion(0.1000001f, 0.2000001f, 0.3000001f, 1.0f).GetNormalized();
bool emCheck = MCore::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).Normalized() == MCore::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).Normalized();
bool emCheck2 = MCore::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).Normalized() == MCore::Quaternion(0.1000001f, 0.2000001f, 0.3000001f, 1.0f).Normalized();
bool emCheck3 = MCore::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).Normalized() != MCore::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).Normalized();
bool emCheck4 = MCore::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).Normalized() != MCore::Quaternion(0.1000001f, 0.2000001f, 0.3000001f, 1.0f).Normalized();
EXPECT_TRUE(azCheck == emCheck) << "AZ/MCore Quaternions should have same output of 'true' with operator '=='";
EXPECT_TRUE(azCheck2 == emCheck2) << "AZ/MCore Quaternions should have same output of 'false' with operator '=='";
EXPECT_TRUE(azCheck3 == emCheck3) << "AZ/MCore Quaternions should have same output of 'false' with operator '!='";
EXPECT_TRUE(azCheck4 == emCheck4) << "AZ/MCore Quaternions should have same output of 'true' with operator '!='";
}
TEST_F(EmotionFXMathLibTests, AZEMQuaternion_InverseHasSimilarOutput_Success)
{
// Test quaternions inverse method
AZ::Quaternion azQuaternion = AZ::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).GetNormalized().GetInverseFull();
AZ::Quaternion azQuaternion2 = AZ::Quaternion(0.0f, 0.0f, 0.0f, 1.0f).GetNormalized().GetInverseFull();
MCore::Quaternion emQuaternion = MCore::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).Normalized().Inverse();
MCore::Quaternion emQuaternion2 = MCore::Quaternion(0.0f, 0.0f, 0.0f, 1.0f).Normalized().Inverse();
EXPECT_TRUE(AZEMQuaternionsAreClose(azQuaternion, emQuaternion, s_toleranceLow)) << "AZ/MCore Quaternions should have similar Inverse output";
EXPECT_TRUE(AZEMQuaternionsAreClose(azQuaternion2, emQuaternion2, s_toleranceLow)) << "AZ/MCore Quaternion(0.0f, 0.0f, 0.0f, 1.0f) should have similar Inverse output";
}
TEST_F(EmotionFXMathLibTests, AZEMQuaternion_ConjugateHasSimilarOutput_Success)
{
// Test quaternion conjugate method
AZ::Quaternion azQuaternion = AZ::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).GetNormalized().GetConjugate();
AZ::Quaternion azQuaternion2 = AZ::Quaternion(0.0f, 0.0f, 0.0f, 1.0f).GetNormalized().GetConjugate();
MCore::Quaternion emQuaternion = MCore::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).Normalized().Conjugate();
MCore::Quaternion emQuaternion2 = MCore::Quaternion(0.0f, 0.0f, 0.0f, 1.0f).Normalized().Conjugate();
EXPECT_TRUE(AZEMQuaternionsAreClose(azQuaternion, emQuaternion, s_toleranceLow)) << "AZ/MCore Quaternions should have similar Conjugate output";
EXPECT_TRUE(AZEMQuaternionsAreClose(azQuaternion2, emQuaternion2, s_toleranceLow)) << "AZ/MCore Quaternion(0.0f, 0.0f, 0.0f, 1.0f) should have similar Conjugate output";
}
TEST_F(EmotionFXMathLibTests, AZEMQuaternion_HasSameSquareLengthOutput_Success)
{
// Test AZ and MCore quaternions to have similar square length
float azTest = AZ::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).GetNormalized().GetLengthSq();
float azTest2 = AZ::Quaternion(0.0f, 0.0f, 0.0f, 1.0f).GetNormalized().GetLengthSq();
float emTest = MCore::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).Normalized().SquareLength();
float emTest2 = MCore::Quaternion(0.0f, 0.0f, 0.0f, 1.0f).Normalized().SquareLength();
EXPECT_TRUE(AZ::GetAbs(azTest - emTest) < s_toleranceLow) << "AZ/MCore Quaternions should have similar square length output";
EXPECT_TRUE(AZ::GetAbs(azTest2 - emTest2) < s_toleranceLow) << "AZ/MCore Quaternion(0.0f, 0.0f, 0.0f, 1.0f) should have similar square length output";
}
TEST_F(EmotionFXMathLibTests, AZEMQuaternion_HasSameLengthOutput_Success)
{
// Test AZ and MCore quaternions to have similar length
// AZ GetLength, GetLengthApprox, GetLength all returns sqrtf(Dot(*this))
float azTest = AZ::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).GetNormalized().GetLength();
float azTest2 = AZ::Quaternion(0.0f, 0.0f, 0.0f, 1.0f).GetNormalized().GetLength();
float emTest = MCore::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).Normalized().Length();
float emTest2 = MCore::Quaternion(0.0f, 0.0f, 0.0f, 1.0f).Normalized().Length();
EXPECT_TRUE(AZ::GetAbs(azTest - emTest) < s_toleranceLow) << "AZ/MCore Quaternions should have similar length output";
EXPECT_TRUE(AZ::GetAbs(azTest2 - emTest2) < s_toleranceLow) << "AZ/MCore Quaternion(0.0f, 0.0f, 0.0f, 1.0f) should have similar length output";
}
TEST_F(EmotionFXMathLibTests, AZEMQuaternion_HasSameDotProductOutput_Success)
{
// Test AZ and MCore quaternions to have similar dot product
float azDotTest = AZ::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).GetNormalized().Dot(AZ::Quaternion(0.8f, 0.7f, 0.6f, 1.0f));
float azDotTest2 = AZ::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).GetNormalized().Dot(AZ::Quaternion(0.0f, 0.0f, 0.0f, 1.0f));
float azDotTest3 = AZ::Quaternion(0.0f, 0.0f, 0.0f, 1.0f).GetNormalized().Dot(AZ::Quaternion(0.0f, 0.0f, 0.0f, 1.0f));
float emDotTest = MCore::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).Normalized().Dot(MCore::Quaternion(0.8f, 0.7f, 0.6f, 1.0f));
float emDotTest2 = MCore::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).Normalized().Dot(MCore::Quaternion(0.0f, 0.0f, 0.0f, 1.0f));
float emDotTest3 = MCore::Quaternion(0.0f, 0.0f, 0.0f, 1.0f).Normalized().Dot(MCore::Quaternion(0.0f, 0.0f, 0.0f, 1.0f));
EXPECT_TRUE(AZ::GetAbs(azDotTest - emDotTest) < s_toleranceLow) << "AZ/MCore Quaternions should have similar dot product output";
EXPECT_TRUE(AZ::GetAbs(azDotTest2 - emDotTest2) < s_toleranceLow) << "AZ/MCore Quaternions should have similar dot product output";
EXPECT_TRUE(AZ::GetAbs(azDotTest3 - emDotTest3) < s_toleranceLow) << "AZ/MCore Quaternion(0.0f, 0.0f, 0.0f, 1.0f) should have similar dot product output";
}
TEST_F(EmotionFXMathLibTests, AZEMQuaternion_HasSimilarLerpOutput_Success)
{
// Test AZ and MCore quaternions to have similar Linear Interpolated quaternions
float testCases[6] = { 0.0f, 0.1f, 0.25f, 0.5f, 0.8f, 1.0f };
for (float testVal : testCases)
{
AZ::Quaternion azQuaternionA = AZ::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).GetNormalized();
AZ::Quaternion azQuaternionB = AZ::Quaternion(0.8f, 0.7f, 0.6f, 1.0f).GetNormalized();
AZ::Quaternion azQuaternionC = azQuaternionA.Lerp(azQuaternionB, testVal);
MCore::Quaternion emQuaternionA = MCore::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).Normalized();
MCore::Quaternion emQuaternionB = MCore::Quaternion(0.8f, 0.7f, 0.6f, 1.0f).Normalized();
MCore::Quaternion emQuaternionC = emQuaternionA.Lerp(emQuaternionB, testVal);
EXPECT_TRUE(AZEMQuaternionsAreClose(azQuaternionA, emQuaternionA, s_toleranceLow)) << "AZ/MCore Quaternions should have similar Lerp output with given float: " << testVal;
}
}
TEST_F(EmotionFXMathLibTests, AZEMQuaternion_HasSimilarNLerpOutput_Success)
{
// Test AZ and MCore quaternions to have similar Linear Interpolated and then normalized quaternions
float testCases[6] = {0.0f, 0.1f, 0.25f, 0.5f, 0.8f, 1.0f};
for (float testVal : testCases)
{
AZ::Quaternion azQuaternionA = AZ::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).GetNormalized();
AZ::Quaternion azQuaternionB = AZ::Quaternion(0.8f, 0.7f, 0.6f, 1.0f).GetNormalized();
AZ::Quaternion azQuaternionC = azQuaternionA.NLerp(azQuaternionB, testVal);
MCore::Quaternion emQuaternionA = MCore::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).Normalized();
MCore::Quaternion emQuaternionB = MCore::Quaternion(0.8f, 0.7f, 0.6f, 1.0f).Normalized();
MCore::Quaternion emQuaternionC = emQuaternionA.NLerp(emQuaternionB, testVal);
EXPECT_TRUE(AZEMQuaternionsAreClose(azQuaternionA, emQuaternionA, s_toleranceLow)) << "AZ/MCore Quaternions should have similar NLerp output with given float: " << testVal;
}
}
TEST_F(EmotionFXMathLibTests, AZEMQuaternion_HasSimilarSLerpOutput_Success)
{
// Test AZ and MCore quaternions to have similar spherical Linear Interpolated quaternions
float testCases[6] = { 0.0f, 0.1f, 0.25f, 0.5f, 0.8f, 1.0f };
for (float testVal : testCases)
{
AZ::Quaternion azQuaternionA = AZ::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).GetNormalized();
AZ::Quaternion azQuaternionB = AZ::Quaternion(0.8f, 0.7f, 0.6f, 1.0f).GetNormalized();
AZ::Quaternion azQuaternionC = azQuaternionA.Slerp(azQuaternionB, testVal);
MCore::Quaternion emQuaternionA = MCore::Quaternion(0.1f, 0.2f, 0.3f, 1.0f).Normalized();
MCore::Quaternion emQuaternionB = MCore::Quaternion(0.8f, 0.7f, 0.6f, 1.0f).Normalized();
MCore::Quaternion emQuaternionC = emQuaternionA.Slerp(emQuaternionB, testVal);
EXPECT_TRUE(AZEMQuaternionsAreClose(azQuaternionA, emQuaternionA, s_toleranceLow)) << "AZ/MCore Quaternions should have similar Slerp output with given float: " << testVal;
}
}
//////////////////////////////////////////////////////////////////
// Skinning
//////////////////////////////////////////////////////////////////
Gems/EMotionFX/Code/Tests/Matchers.h
+1 -32
View File
@@ -13,8 +13,8 @@
#include <AzCore/Math/Quaternion.h>
#include <EMotionFX/Source/EMotionFXConfig.h>
#include <EMotionFX/Source/Transform.h>
#include <MCore/Source/Quaternion.h>
#include <MCore/Source/Compare.h>
#include <MCore/Source/Matrix4.h>
#include <Tests/Printers.h>
#include <AzCore/std/string/string.h>
@@ -76,37 +76,6 @@ inline bool IsCloseMatcherP<AZ::Quaternion>::gmock_Impl<const AZ::Quaternion&>::
return false;
}
template<>
template<>
inline bool IsCloseMatcherP<MCore::Quaternion>::gmock_Impl<const MCore::Quaternion&>::MatchAndExplain(const MCore::Quaternion& arg, ::testing::MatchResultListener* result_listener) const
{
const MCore::Quaternion compareQuat = (expected.Dot(arg) < 0.0f) ? -arg : arg;
const AZ::Vector4 compareVec4(compareQuat.x, compareQuat.y, compareQuat.z, compareQuat.w);
if (::testing::ExplainMatchResult(IsClose(AZ::Vector4(expected.x, expected.y, expected.z, expected.w)), compareVec4, result_listener))
{
return true;
}
AZ::Vector3 gotAxis;
AZ::Vector3 expectedAxis;
float gotAngle;
float expectedAngle;
// convert to an axis and angle representation
expected.ToAxisAngle(&expectedAxis, &expectedAngle);
compareQuat.ToAxisAngle(&gotAxis, &gotAngle);
*result_listener << "\n Got Axis: ";
PrintTo(gotAxis, result_listener->stream());
*result_listener << ", Got Angle: " << gotAngle << "\n";
*result_listener << "Expected Axis: ";
PrintTo(expectedAxis, result_listener->stream());
*result_listener << ", Expected Angle: " << expectedAngle;
return false;
}
template<>
template<>
inline bool IsCloseMatcherP<EMotionFX::Transform>::gmock_Impl<const EMotionFX::Transform&>::MatchAndExplain(const EMotionFX::Transform& arg, ::testing::MatchResultListener* result_listener) const
Gems/EMotionFX/Code/Tests/Printers.cpp
-12
View File
@@ -34,18 +34,6 @@ namespace AZStd
}
} // namespace AZStd
namespace MCore
{
void PrintTo(const Quaternion& quaternion, ::std::ostream* os)
{
*os << "(x: " << quaternion.x
<< ", y: " << quaternion.y
<< ", z: " << quaternion.z
<< ", w: " << quaternion.w
<< ")";
}
} // namespace MCore
namespace EMotionFX
{
void PrintTo(const Transform& transform, ::std::ostream* os)
Gems/EMotionFX/Code/Tests/Printers.h
-6
View File
@@ -11,7 +11,6 @@
#include <AzCore/std/string/string.h>
#include <AzCore/Math/Vector3.h>
#include <AzCore/Math/Quaternion.h>
#include <MCore/Source/Quaternion.h>
#include <EMotionFX/Source/Transform.h>
namespace AZ
@@ -25,11 +24,6 @@ namespace AZStd
void PrintTo(const string& string, ::std::ostream* os);
} // namespace AZStd
namespace MCore
{
void PrintTo(const Quaternion& quaternion, ::std::ostream* os);
} // namespace MCore
namespace EMotionFX
{
void PrintTo(const Transform& transform, ::std::ostream* os);