diff --git a/Code/Framework/AzCore/AzCore/Component/TransformBus.h b/Code/Framework/AzCore/AzCore/Component/TransformBus.h index 2003b949e2..be18593d54 100644 --- a/Code/Framework/AzCore/AzCore/Component/TransformBus.h +++ b/Code/Framework/AzCore/AzCore/Component/TransformBus.h @@ -287,71 +287,28 @@ namespace AZ //! Scale modifiers //! @{ - //! @deprecated Use SetLocalScale() - //! Scales the entity along the world's axes. The origin of the axes is the entity's position in the world. - //! @param scale A three-dimensional vector that represents the multipliers with which to scale the entity in world space. - virtual void SetScale([[maybe_unused]] const AZ::Vector3& scale) {} - - //! @deprecated Use SetLocalScaleX() - //! Scales the entity along the world's X axis. The origin of the axis is the entity's position in the world. - //! @param scaleX The multiplier by which to scale the entity along the X axis in world space. - virtual void SetScaleX([[maybe_unused]] float scaleX) {} - - //! @deprecated Use SetLocalScaleY() - //! Scales the entity along the world's Y axis. The origin of the axis is the entity's position in the world. - //! @param scaleY The multiplier by which to scale the entity along the Y axis in world space. - virtual void SetScaleY([[maybe_unused]] float scaleY) {} - - //! @deprecated Use SetLocalScaleZ() - //! Scales the entity along the world's Z axis. The origin of the axis is the entity's position in the world. - //! @param scaleZ The multiplier by which to scale the entity along the Z axis in world space. - virtual void SetScaleZ([[maybe_unused]] float scaleZ) {} - - //! @deprecated Use GetLocalScale() - //! Gets the scale of the entity in world space. - //! @return A three-dimensional vector that represents the scale of the entity in world space. - virtual AZ::Vector3 GetScale() { return AZ::Vector3(FLT_MAX); } - - //! @deprecated Use GetLocalScale() - //! Gets the amount by which an entity is scaled along the world's X axis. - //! @return The amount by which an entity is scaled along the X axis in world space. - virtual float GetScaleX() { return FLT_MAX; } - - //! @deprecated Use GetLocalScale() - //! Gets the amount by which an entity is scaled along the world's Y axis. - //! @return The amount by which an entity is scaled along the Y axis in world space. - virtual float GetScaleY() { return FLT_MAX; } - - //! @deprecated Use GetLocalScale() - //! Gets the amount by which an entity is scaled along the world's Z axis. - //! @return The amount by which an entity is scaled along the Z axis in world space. - virtual float GetScaleZ() { return FLT_MAX; } - //! Set local scale of the transform. - //! @param scale The new scale to set along three local axes. + //! @param scale The new scale to set. virtual void SetLocalScale([[maybe_unused]] const AZ::Vector3& scale) {} - //! Set local scale of the transform on x-axis. - //! @param scaleX The new x-axis scale to set. - virtual void SetLocalScaleX([[maybe_unused]] float scaleX) {} - - //! Set local scale of the transform on y-axis. - //! @param scaleY The new y-axis scale to set. - virtual void SetLocalScaleY([[maybe_unused]] float scaleY) {} - - //! Set local scale of the transform on z-axis. - //! @param scaleZ The new z-axis scale to set. - virtual void SetLocalScaleZ([[maybe_unused]] float scaleZ) {} - - //! Get the scale value on each axis in local space - //! @return The scale value of type Vector3 along each axis in local space. + //! Get the scale value in local space. + //! @return The scale value in local space. virtual AZ::Vector3 GetLocalScale() { return AZ::Vector3(FLT_MAX); } - //! Get the scale value on each axis in world space. - //! Note the transform will be skewed when it is rotated and has a parent transform scaled, in which - //! case the returned world-scale from this function will be inaccurate. - //! @return The scale value of type Vector3 along each axis in world space. + //! Get the scale value in world space. + //! @return The scale value in world space. virtual AZ::Vector3 GetWorldScale() { return AZ::Vector3(FLT_MAX); } + + //! Set the uniform scale value in local space. + virtual void SetLocalUniformScale([[maybe_unused]] float scale) {} + + //! Get the uniform scale value in local space. + //! @return The uniform scale value in local space. + virtual float GetLocalUniformScale() { return FLT_MAX; } + + //! Get the uniform scale value in world space. + //! @return The uniform scale value in world space. + virtual float GetWorldUniformScale() { return FLT_MAX; } //! @} //! Transform hierarchy diff --git a/Code/Framework/AzCore/AzCore/Math/Quaternion.cpp b/Code/Framework/AzCore/AzCore/Math/Quaternion.cpp index 143fe59ca7..06443c0698 100644 --- a/Code/Framework/AzCore/AzCore/Math/Quaternion.cpp +++ b/Code/Framework/AzCore/AzCore/Math/Quaternion.cpp @@ -348,13 +348,20 @@ namespace AZ return result.GetW() >= 0.0f ? result : -result; } - const Quaternion Quaternion::CreateFromEulerAnglesDegrees(Vector3& anglesInDegrees) + const Quaternion Quaternion::CreateFromEulerAnglesDegrees(const Vector3& anglesInDegrees) { Quaternion result; result.SetFromEulerDegrees(anglesInDegrees); return result; } + const Quaternion Quaternion::CreateFromEulerAnglesRadians(const Vector3& anglesInRadians) + { + Quaternion result; + result.SetFromEulerRadians(anglesInRadians); + return result; + } + Quaternion Quaternion::Slerp(const Quaternion& dest, float t) const { const float DestDot = Dot(dest); diff --git a/Code/Framework/AzCore/AzCore/Math/Quaternion.h b/Code/Framework/AzCore/AzCore/Math/Quaternion.h index c4502063de..4d3b6641db 100644 --- a/Code/Framework/AzCore/AzCore/Math/Quaternion.h +++ b/Code/Framework/AzCore/AzCore/Math/Quaternion.h @@ -83,8 +83,11 @@ namespace AZ static Quaternion CreateShortestArc(const Vector3& v1, const Vector3& v2); - /// Creates a quaternion using rotation in degrees about the axes. First rotated about the X axis, followed by the Y axis, then the Z axis. - static const Quaternion CreateFromEulerAnglesDegrees(Vector3& anglesInDegrees); + //! Creates a quaternion using rotation in degrees about the axes. First rotated about the X axis, followed by the Y axis, then the Z axis. + static const Quaternion CreateFromEulerAnglesDegrees(const Vector3& anglesInDegrees); + + //! Creates a quaternion using rotation in radians about the axes. First rotated about the X axis, followed by the Y axis, then the Z axis. + static const Quaternion CreateFromEulerAnglesRadians(const Vector3& anglesInRadians); //! Stores the vector to an array of 4 floats. The floats need only be 4 byte aligned, 16 byte alignment is not required. void StoreToFloat4(float* values) const; diff --git a/Code/Framework/AzCore/AzCore/Math/Spline.h b/Code/Framework/AzCore/AzCore/Math/Spline.h index 912c10f46f..1adfc9b2fa 100644 --- a/Code/Framework/AzCore/AzCore/Math/Spline.h +++ b/Code/Framework/AzCore/AzCore/Math/Spline.h @@ -441,10 +441,10 @@ namespace AZ const Transform& worldFromLocal, const Vector3& src, const Vector3& dir, const Spline& spline) { Transform worldFromLocalNormalized = worldFromLocal; - const Vector3 scale = worldFromLocalNormalized.ExtractScale(); + const float scale = worldFromLocalNormalized.ExtractUniformScale(); const Transform localFromWorldNormalized = worldFromLocalNormalized.GetInverse(); - const Vector3 localRayOrigin = localFromWorldNormalized.TransformPoint(src) * scale.GetReciprocal(); + const Vector3 localRayOrigin = localFromWorldNormalized.TransformPoint(src) / scale; const Vector3 localRayDirection = localFromWorldNormalized.TransformVector(dir); return spline.GetNearestAddressRay(localRayOrigin, localRayDirection); } diff --git a/Code/Framework/AzCore/AzCore/Math/Transform.cpp b/Code/Framework/AzCore/AzCore/Math/Transform.cpp index bb3f764492..9090a9e94e 100644 --- a/Code/Framework/AzCore/AzCore/Math/Transform.cpp +++ b/Code/Framework/AzCore/AzCore/Math/Transform.cpp @@ -284,10 +284,15 @@ namespace AZ Method("GetRotation", &Transform::GetRotation)-> Method("SetRotation", &Transform::SetRotation)-> Method("GetScale", &Transform::GetScale)-> - Method("SetScale", &Transform::SetScale)-> + Method("GetUniformScale", &Transform::GetUniformScale)-> + Method("SetScale", &Transform::SetScale)-> + Method("SetUniformScale", &Transform::SetUniformScale)-> Method("ExtractScale", &Transform::ExtractScale)-> Attribute(Script::Attributes::ExcludeFrom, Script::Attributes::ExcludeFlags::All)-> + Method("ExtractUniformScale", &Transform::ExtractUniformScale)-> + Attribute(Script::Attributes::ExcludeFrom, Script::Attributes::ExcludeFlags::All)-> Method("MultiplyByScale", &Transform::MultiplyByScale)-> + Method("MultiplyByUniformScale", &Transform::MultiplyByUniformScale)-> Method("GetInverse", &Transform::GetInverse)-> Method("Invert", &Transform::Invert)-> Attribute(Script::Attributes::ExcludeFrom, Script::Attributes::ExcludeFlags::All)-> @@ -306,6 +311,7 @@ namespace AZ Method("CreateFromMatrix3x3", &Transform::CreateFromMatrix3x3)-> Method("CreateFromMatrix3x3AndTranslation", &Transform::CreateFromMatrix3x3AndTranslation)-> Method("CreateScale", &Transform::CreateScale)-> + Method("CreateUniformScale", &Transform::CreateUniformScale)-> Method("CreateTranslation", &Transform::CreateTranslation)-> Method("ConstructFromValuesNumeric", &Internal::ConstructTransformFromValues); } diff --git a/Code/Framework/AzCore/AzCore/Math/Transform.h b/Code/Framework/AzCore/AzCore/Math/Transform.h index eb1a12a912..7ae86edd89 100644 --- a/Code/Framework/AzCore/AzCore/Math/Transform.h +++ b/Code/Framework/AzCore/AzCore/Math/Transform.h @@ -89,8 +89,11 @@ namespace AZ static Transform CreateFromMatrix3x4(const Matrix3x4& value); - //! Sets the matrix to be a scale matrix, translation is set to zero. - static Transform CreateScale(const Vector3& scale); + //! Sets the transform to apply scale only, no rotation or translation. + static Transform CreateScale(const AZ::Vector3& scale); + + //! Sets the transform to apply (uniform) scale only, no rotation or translation. + static Transform CreateUniformScale(const float scale); //! Sets the matrix to be a translation matrix, rotation part is set to identity. static Transform CreateTranslation(const Vector3& translation); @@ -119,13 +122,19 @@ namespace AZ const Quaternion& GetRotation() const; void SetRotation(const Quaternion& rotation); - const Vector3& GetScale() const; + Vector3 GetScale() const; + float GetUniformScale() const; void SetScale(const Vector3& v); + void SetUniformScale(const float scale); - //! Sets the transforms scale to a unit value and returns the previous scale value. + //! Sets the transform's scale to a unit value and returns the previous scale value. Vector3 ExtractScale(); - void MultiplyByScale(const Vector3& scale); + //! Sets the transform's scale to a unit value and returns the previous scale value. + float ExtractUniformScale(); + + void MultiplyByScale(const AZ::Vector3& scale); + void MultiplyByUniformScale(float scale); Transform operator*(const Transform& rhs) const; Transform& operator*=(const Transform& rhs); diff --git a/Code/Framework/AzCore/AzCore/Math/Transform.inl b/Code/Framework/AzCore/AzCore/Math/Transform.inl index 63425e6e41..a7d5e72749 100644 --- a/Code/Framework/AzCore/AzCore/Math/Transform.inl +++ b/Code/Framework/AzCore/AzCore/Math/Transform.inl @@ -65,6 +65,7 @@ namespace AZ AZ_MATH_INLINE Transform Transform::CreateScale(const Vector3& scale) { + AZ_WarningOnce("Transform", false, "CreateScale is deprecated, please use CreateUniformScale instead."); Transform result; result.m_rotation = Quaternion::CreateIdentity(); result.m_scale = scale; @@ -72,6 +73,15 @@ namespace AZ return result; } + AZ_MATH_INLINE Transform Transform::CreateUniformScale(float scale) + { + Transform result; + result.m_rotation = Quaternion::CreateIdentity(); + result.m_scale = Vector3(scale); + result.m_translation = Vector3::CreateZero(); + return result; + } + AZ_MATH_INLINE Transform Transform::CreateTranslation(const Vector3& translation) { Transform result; @@ -150,24 +160,50 @@ namespace AZ m_rotation = rotation; } - AZ_MATH_INLINE const Vector3& Transform::GetScale() const + AZ_MATH_INLINE Vector3 Transform::GetScale() const { + AZ_WarningOnce("Transform", false, "GetScale is deprecated, please use GetUniformScale instead."); return m_scale; } + AZ_MATH_INLINE float Transform::GetUniformScale() const + { + return m_scale.GetMaxElement(); + } + AZ_MATH_INLINE void Transform::SetScale(const Vector3& scale) { + AZ_WarningOnce("Transform", false, "SetScale is deprecated, please use SetUniformScale instead."); m_scale = scale; } + AZ_MATH_INLINE void Transform::SetUniformScale(const float scale) + { + m_scale = Vector3(scale); + } + AZ_MATH_INLINE Vector3 Transform::ExtractScale() { + AZ_WarningOnce("Transform", false, "ExtractScale is deprecated, please use ExtractUniformScale instead."); const Vector3 scale = m_scale; m_scale = Vector3::CreateOne(); return scale; } + AZ_MATH_INLINE float Transform::ExtractUniformScale() + { + const float scale = m_scale.GetMaxElement(); + m_scale = Vector3::CreateOne(); + return scale; + } + AZ_MATH_INLINE void Transform::MultiplyByScale(const Vector3& scale) + { + AZ_WarningOnce("Transform", false, "MultiplyByScale is deprecated, please use MultiplyByUniformScale instead."); + m_scale *= scale; + } + + AZ_MATH_INLINE void Transform::MultiplyByUniformScale(float scale) { m_scale *= scale; } @@ -233,7 +269,7 @@ namespace AZ AZ_MATH_INLINE void Transform::Orthogonalize() { - *this = GetOrthogonalized(); + m_scale = Vector3::CreateOne(); } AZ_MATH_INLINE bool Transform::IsClose(const Transform& rhs, float tolerance) const diff --git a/Code/Framework/AzCore/AzCore/Math/TransformSerializer.cpp b/Code/Framework/AzCore/AzCore/Math/TransformSerializer.cpp index 0a3e02ee0d..86bc1c36ea 100644 --- a/Code/Framework/AzCore/AzCore/Math/TransformSerializer.cpp +++ b/Code/Framework/AzCore/AzCore/Math/TransformSerializer.cpp @@ -60,7 +60,7 @@ namespace AZ { // Scale is transitioning to a single uniform scale value, but since it's still internally represented as a Vector3, // we need to pick one number to use for load/store operations. - float scale = transformInstance->GetScale().GetMaxElement(); + float scale = transformInstance->GetUniformScale(); JSR::ResultCode loadResult = ContinueLoadingFromJsonObjectField(&scale, azrtti_typeid(), inputValue, ScaleTag, context); @@ -124,8 +124,8 @@ namespace AZ // Scale is transitioning to a single uniform scale value, but since it's still internally represented as a Vector3, // we need to pick one number to use for load/store operations. - float scale = transformInstance->GetScale().GetMaxElement(); - float defaultScale = defaultTransformInstance ? defaultTransformInstance->GetScale().GetMaxElement() : 0.0f; + float scale = transformInstance->GetUniformScale(); + float defaultScale = defaultTransformInstance ? defaultTransformInstance->GetUniformScale() : 0.0f; JSR::ResultCode storeResult = ContinueStoringToJsonObjectField( outputValue, ScaleTag, &scale, defaultTransformInstance ? &defaultScale : nullptr, azrtti_typeid(), diff --git a/Code/Framework/AzCore/Tests/AZTestShared/Utils/Utils.cpp b/Code/Framework/AzCore/Tests/AZTestShared/Utils/Utils.cpp index 38b9cd609b..9c6f85f08a 100644 --- a/Code/Framework/AzCore/Tests/AZTestShared/Utils/Utils.cpp +++ b/Code/Framework/AzCore/Tests/AZTestShared/Utils/Utils.cpp @@ -31,6 +31,8 @@ namespace UnitTest ErrorHandler::ErrorHandler(const char* errorPattern) : m_errorCount(0) , m_warningCount(0) + , m_expectedErrorCount(0) + , m_expectedWarningCount(0) , m_errorPattern(errorPattern) { AZ::Debug::TraceMessageBus::Handler::BusConnect(); @@ -51,6 +53,16 @@ namespace UnitTest return m_warningCount; } + int ErrorHandler::GetExpectedErrorCount() const + { + return m_expectedErrorCount; + } + + int ErrorHandler::GetExpectedWarningCount() const + { + return m_expectedWarningCount; + } + bool ErrorHandler::SuppressExpectedErrors([[maybe_unused]] const char* window, const char* message) { return AZStd::string(message).find(m_errorPattern) != AZStd::string::npos; @@ -61,7 +73,9 @@ namespace UnitTest [[maybe_unused]] const char* func, const char* message) { m_errorCount++; - return SuppressExpectedErrors(window, message); + bool suppress = SuppressExpectedErrors(window, message); + m_expectedErrorCount += suppress; + return suppress; } bool ErrorHandler::OnPreWarning( @@ -69,7 +83,9 @@ namespace UnitTest [[maybe_unused]] const char* func, const char* message) { m_warningCount++; - return SuppressExpectedErrors(window, message); + bool suppress = SuppressExpectedErrors(window, message); + m_expectedWarningCount += suppress; + return suppress; } bool ErrorHandler::OnPrintf(const char* window, const char* message) diff --git a/Code/Framework/AzCore/Tests/AZTestShared/Utils/Utils.h b/Code/Framework/AzCore/Tests/AZTestShared/Utils/Utils.h index 044c3d1111..56ef340d22 100644 --- a/Code/Framework/AzCore/Tests/AZTestShared/Utils/Utils.h +++ b/Code/Framework/AzCore/Tests/AZTestShared/Utils/Utils.h @@ -30,8 +30,14 @@ namespace UnitTest public: explicit ErrorHandler(const char* errorPattern); ~ErrorHandler(); + //! Returns the total number of errors encountered (including those which match the expected pattern). int GetErrorCount() const; + //! Returns the total number of warnings encountered (including those which match the expected pattern). int GetWarningCount() const; + //! Returns the number of errors encountered which matched the expected pattern. + int GetExpectedErrorCount() const; + //! Returns the number of warnings encountered which matched the expected pattern. + int GetExpectedWarningCount() const; bool SuppressExpectedErrors(const char* window, const char* message); // AZ::Debug::TraceMessageBus @@ -44,6 +50,8 @@ namespace UnitTest AZStd::string m_errorPattern; int m_errorCount; int m_warningCount; + int m_expectedErrorCount; + int m_expectedWarningCount; }; } diff --git a/Code/Framework/AzCore/Tests/Math/MathTestData.h b/Code/Framework/AzCore/Tests/Math/MathTestData.h index cd3ade7854..c82c5caea7 100644 --- a/Code/Framework/AzCore/Tests/Math/MathTestData.h +++ b/Code/Framework/AzCore/Tests/Math/MathTestData.h @@ -61,8 +61,8 @@ namespace MathTestData }; static const AZ::Transform NonOrthogonalTransforms[] = { - AZ::Transform::CreateScale(AZ::Vector3(2.4f, 0.3f, 1.7f)), - AZ::Transform::CreateRotationX(2.2f) * AZ::Transform::CreateScale(AZ::Vector3(0.2f, 0.8f, 1.4f)) + AZ::Transform::CreateUniformScale(2.4f), + AZ::Transform::CreateRotationX(2.2f) * AZ::Transform::CreateUniformScale(0.8f) }; static const AZ::Transform OrthogonalTransforms[] = { diff --git a/Code/Framework/AzCore/Tests/Math/ObbTests.cpp b/Code/Framework/AzCore/Tests/Math/ObbTests.cpp index a90d66f288..de267b4265 100644 --- a/Code/Framework/AzCore/Tests/Math/ObbTests.cpp +++ b/Code/Framework/AzCore/Tests/Math/ObbTests.cpp @@ -59,11 +59,11 @@ namespace UnitTest TEST(MATH_Obb, TestScaleTransform) { Obb obb = Obb::CreateFromPositionRotationAndHalfLengths(position, rotation, halfLengths); - Vector3 scaleFactors = Vector3(1.0f, 2.0f, 3.0f); - Transform transform = Transform::CreateScale(scaleFactors); + float scale = 3.0f; + Transform transform = Transform::CreateUniformScale(scale); obb = transform * obb; - EXPECT_THAT(obb.GetPosition(), IsClose(Vector3(1.0f, 4.0f, 9.0f))); - EXPECT_THAT(obb.GetHalfLengths(), IsClose(Vector3(0.5f, 1.0f, 1.5f))); + EXPECT_THAT(obb.GetPosition(), IsClose(Vector3(3.0f, 6.0f, 9.0f))); + EXPECT_THAT(obb.GetHalfLengths(), IsClose(Vector3(1.5f, 1.5f, 1.5f))); } TEST(MATH_Obb, TestSetPosition) diff --git a/Code/Framework/AzCore/Tests/Math/TransformPerformanceTests.cpp b/Code/Framework/AzCore/Tests/Math/TransformPerformanceTests.cpp index 400a845913..943aba9b76 100644 --- a/Code/Framework/AzCore/Tests/Math/TransformPerformanceTests.cpp +++ b/Code/Framework/AzCore/Tests/Math/TransformPerformanceTests.cpp @@ -180,13 +180,13 @@ namespace Benchmark } } - BENCHMARK_F(BM_MathTransform, CreateScale)(benchmark::State& state) + BENCHMARK_F(BM_MathTransform, CreateUniformScale)(benchmark::State& state) { for (auto _ : state) { for (auto& testData : m_testDataArray) { - AZ::Transform result = AZ::Transform::CreateScale(testData.v3); + AZ::Transform result = AZ::Transform::CreateUniformScale(testData.value[0]); benchmark::DoNotOptimize(result); } } @@ -344,39 +344,39 @@ namespace Benchmark } } - BENCHMARK_F(BM_MathTransform, GetScale)(benchmark::State& state) + BENCHMARK_F(BM_MathTransform, GetUniformScale)(benchmark::State& state) { for (auto _ : state) { for (auto& testData : m_testDataArray) { - AZ::Vector3 result = testData.t1.GetScale(); + float result = testData.t1.GetUniformScale(); benchmark::DoNotOptimize(result); } } } - BENCHMARK_F(BM_MathTransform, SetScale)(benchmark::State& state) + BENCHMARK_F(BM_MathTransform, SetUniformScale)(benchmark::State& state) { for (auto _ : state) { for (auto& testData : m_testDataArray) { AZ::Transform testTransform = testData.t2; - testTransform.SetScale(testData.v3); + testTransform.SetUniformScale(testData.value[0]); benchmark::DoNotOptimize(testTransform); } } } - BENCHMARK_F(BM_MathTransform, ExtractScale)(benchmark::State& state) + BENCHMARK_F(BM_MathTransform, ExtractUniformScale)(benchmark::State& state) { for (auto _ : state) { for (auto& testData : m_testDataArray) { AZ::Transform testTransform = testData.t2; - AZ::Vector3 result = testTransform.ExtractScale(); + float result = testTransform.ExtractUniformScale(); benchmark::DoNotOptimize(result); } } diff --git a/Code/Framework/AzCore/Tests/Math/TransformTests.cpp b/Code/Framework/AzCore/Tests/Math/TransformTests.cpp index d0343211c3..529347f31d 100644 --- a/Code/Framework/AzCore/Tests/Math/TransformTests.cpp +++ b/Code/Framework/AzCore/Tests/Math/TransformTests.cpp @@ -159,37 +159,14 @@ namespace UnitTest INSTANTIATE_TEST_CASE_P(MATH_Transform, TransformCreateFromQuaternionFixture, ::testing::ValuesIn(MathTestData::UnitQuaternions)); - using TransformCreateFromMatrix3x3Fixture = ::testing::TestWithParam; - - TEST_P(TransformCreateFromMatrix3x3Fixture, CreateFromMatrix3x3) + TEST(MATH_Transform, CreateUniformScale) { - const AZ::Matrix3x3 matrix3x3 = GetParam(); - const AZ::Transform transform = AZ::Transform::CreateFromMatrix3x3(matrix3x3); - EXPECT_THAT(transform.GetTranslation(), IsClose(AZ::Vector3::CreateZero())); - const AZ::Vector3 vector(2.3f, -0.6, 1.8f); - EXPECT_THAT(transform.TransformPoint(vector), IsClose(matrix3x3 * vector)); - } - - TEST_P(TransformCreateFromMatrix3x3Fixture, CreateFromMatrix3x3AndTranslation) - { - const AZ::Matrix3x3 matrix3x3 = GetParam(); - const AZ::Vector3 translation(-2.6f, 1.7f, 0.8f); - const AZ::Transform transform = AZ::Transform::CreateFromMatrix3x3AndTranslation(matrix3x3, translation); - EXPECT_THAT(transform.GetTranslation(), IsClose(translation)); - const AZ::Vector3 vector(2.3f, -0.6, 1.8f); - EXPECT_THAT(transform.TransformPoint(vector), IsClose(matrix3x3 * vector + translation)); - } - - INSTANTIATE_TEST_CASE_P(MATH_Transform, TransformCreateFromMatrix3x3Fixture, ::testing::ValuesIn(MathTestData::Matrix3x3s)); - - TEST(MATH_Transform, CreateScale) - { - const AZ::Vector3 scale(1.7f, 0.3f, 2.4f); - const AZ::Transform transform = AZ::Transform::CreateScale(scale); + const float scale = 1.7f; + const AZ::Transform transform = AZ::Transform::CreateUniformScale(scale); const AZ::Vector3 vector(0.2f, -1.6f, 0.4f); EXPECT_THAT(transform.GetTranslation(), IsClose(AZ::Vector3::CreateZero())); const AZ::Vector3 transformedVector = transform.TransformPoint(vector); - const AZ::Vector3 expected(0.34f, -0.48f, 0.96f); + const AZ::Vector3 expected(0.34f, -2.72f, 0.68f); EXPECT_THAT(transformedVector, IsClose(expected)); } @@ -237,10 +214,10 @@ namespace UnitTest TEST(MATH_Transform, MultiplyByTransform) { const AZ::Transform transform1 = AZ::Transform::CreateRotationY(0.3f); - const AZ::Transform transform2 = AZ::Transform::CreateScale(AZ::Vector3(1.3f, 1.5f, 0.4f)); + const AZ::Transform transform2 = AZ::Transform::CreateUniformScale(1.3f); const AZ::Transform transform3 = AZ::Transform::CreateFromQuaternionAndTranslation( AZ::Quaternion(0.42f, 0.46f, -0.66f, 0.42f), AZ::Vector3(2.8f, -3.7f, 1.6f)); - const AZ::Transform transform4 = AZ::Transform::CreateRotationX(-0.7f) * AZ::Transform::CreateScale(AZ::Vector3(0.6f, 1.3f, 0.7f)); + const AZ::Transform transform4 = AZ::Transform::CreateRotationX(-0.7f) * AZ::Transform::CreateUniformScale(0.6f); AZ::Transform transform5 = transform1; transform5 *= transform4; const AZ::Vector3 vector(1.9f, 2.3f, 0.2f); @@ -254,14 +231,14 @@ namespace UnitTest TEST(MATH_Transform, TranslationCorrectInTransformHierarchy) { AZ::Transform parent = AZ::Transform::CreateRotationZ(AZ::DegToRad(45.0f)); - parent.SetScale(AZ::Vector3(3.0f, 2.0f, 1.0f)); + parent.SetUniformScale(3.0f); parent.SetTranslation(AZ::Vector3(0.2f, 0.3f, 0.4f)); AZ::Transform child = AZ::Transform::CreateRotationZ(AZ::DegToRad(90.0f)); child.SetTranslation(AZ::Vector3(0.5f, 0.6f, 0.7f)); const AZ::Transform overallTransform = parent * child; const AZ::Vector3 overallTranslation = overallTransform.GetTranslation(); - const AZ::Vector3 expectedTranslation(0.412132f, 2.20919f, 1.1f); - EXPECT_THAT(overallTranslation, IsClose(AZ::Vector3(0.412132f, 2.20919f, 1.1f))); + const AZ::Vector3 expectedTranslation(-0.012132f, 2.633452f, 2.5f); + EXPECT_THAT(overallTranslation, IsClose(expectedTranslation)); } TEST(MATH_Transform, TransformPointVector3) @@ -337,14 +314,14 @@ namespace UnitTest TEST_P(TransformScaleFixture, Scale) { const AZ::Transform orthogonalTransform = GetParam(); - EXPECT_THAT(orthogonalTransform.GetScale(), IsClose(AZ::Vector3::CreateOne())); + EXPECT_NEAR(orthogonalTransform.GetUniformScale(), 1.0f, AZ::Constants::Tolerance); AZ::Transform unscaledTransform = orthogonalTransform; - unscaledTransform.ExtractScale(); - EXPECT_THAT(unscaledTransform.GetScale(), IsClose(AZ::Vector3::CreateOne())); - const AZ::Vector3 scale(2.8f, 0.7f, 1.3f); + unscaledTransform.ExtractUniformScale(); + EXPECT_NEAR(unscaledTransform.GetUniformScale(), 1.0f, AZ::Constants::Tolerance); + const float scale = 2.8f; AZ::Transform scaledTransform = orthogonalTransform; - scaledTransform.MultiplyByScale(scale); - EXPECT_THAT(scaledTransform.GetScale(), IsClose(scale)); + scaledTransform.MultiplyByUniformScale(scale); + EXPECT_NEAR(scaledTransform.GetUniformScale(), scale, AZ::Constants::Tolerance); } INSTANTIATE_TEST_CASE_P(MATH_Transform, TransformScaleFixture, ::testing::ValuesIn(MathTestData::OrthogonalTransforms)); @@ -353,24 +330,11 @@ namespace UnitTest { EXPECT_TRUE(AZ::Transform::CreateIdentity().IsOrthogonal()); EXPECT_TRUE(AZ::Transform::CreateRotationZ(0.3f).IsOrthogonal()); - EXPECT_FALSE(AZ::Transform::CreateScale(AZ::Vector3(0.8f, 0.3f, 1.2f)).IsOrthogonal()); + EXPECT_FALSE(AZ::Transform::CreateUniformScale(0.8f).IsOrthogonal()); EXPECT_TRUE(AZ::Transform::CreateFromQuaternion(AZ::Quaternion(-0.52f, -0.08f, 0.56f, 0.64f)).IsOrthogonal()); AZ::Transform transform; transform.SetFromEulerRadians(AZ::Vector3(0.2f, 0.4f, 0.1f)); EXPECT_TRUE(transform.IsOrthogonal()); - - // want to test each possible way the transform could fail to be orthogonal, which we can do by testing for one - // axis, then using a rotation which cycles the axes - const AZ::Transform axisCycle = AZ::Transform::CreateFromQuaternion(AZ::Quaternion(0.5f, 0.5f, 0.5f, 0.5f)); - - // a transform which is normalized in 2 axes, but not the third - AZ::Transform nonOrthogonalTransform1 = AZ::Transform::CreateScale(AZ::Vector3(1.0f, 1.0f, 2.0f)); - - for (int i = 0; i < 3; i++) - { - EXPECT_FALSE(nonOrthogonalTransform1.IsOrthogonal()); - nonOrthogonalTransform1 = axisCycle * nonOrthogonalTransform1; - } } using TransformSetFromEulerDegreesFixture = ::testing::TestWithParam; @@ -459,16 +423,17 @@ namespace UnitTest { const char* objectStreamBuffer = R"DELIMITER( - + )DELIMITER"; AZ::Transform* deserializedTransform = AZ::Utils::LoadObjectFromBuffer(objectStreamBuffer, strlen(objectStreamBuffer) + 1); const AZ::Vector3 expectedTranslation(513.7845459f, 492.5420837f, 32.0000000f); - const AZ::Vector3 expectedScale(1.5f, 0.5f, 1.2f); + const float expectedScale = 1.5f; const AZ::Quaternion expectedRotation(0.2624075f, 0.4405251f, 0.2029076f, 0.8342113f); const AZ::Transform expectedTransform = - AZ::Transform::CreateFromQuaternionAndTranslation(expectedRotation, expectedTranslation) * AZ::Transform::CreateScale(expectedScale); + AZ::Transform::CreateFromQuaternionAndTranslation(expectedRotation, expectedTranslation) * + AZ::Transform::CreateUniformScale(expectedScale); EXPECT_TRUE(deserializedTransform->IsClose(expectedTransform)); azfree(deserializedTransform); diff --git a/Code/Framework/AzCore/Tests/ScriptMath.cpp b/Code/Framework/AzCore/Tests/ScriptMath.cpp index cb673e92e7..dce63051c9 100644 --- a/Code/Framework/AzCore/Tests/ScriptMath.cpp +++ b/Code/Framework/AzCore/Tests/ScriptMath.cpp @@ -1275,10 +1275,10 @@ namespace UnitTest script->Execute("AZTestAssert(t1:TransformVector(Vector3(1, 0, 0)):IsClose(Vector3(1, 0, 0)))"); script->Execute("AZTestAssert(t1:TransformVector(Vector3(0, 1, 0)):IsClose(Vector3(0, 0.866, 0.5)))"); script->Execute("AZTestAssert(t1:TransformVector(Vector3(0, 0, 1)):IsClose(Vector3(0, -0.5, 0.866)))"); - script->Execute("t1 = Transform.CreateScale(Vector3(1, 2, 3))"); - script->Execute("AZTestAssert(t1:TransformVector(Vector3(1, 0, 0)):IsClose(Vector3(1, 0, 0)))"); + script->Execute("t1 = Transform.CreateUniformScale(2)"); + script->Execute("AZTestAssert(t1:TransformVector(Vector3(1, 0, 0)):IsClose(Vector3(2, 0, 0)))"); script->Execute("AZTestAssert(t1:TransformVector(Vector3(0, 1, 0)):IsClose(Vector3(0, 2, 0)))"); - script->Execute("AZTestAssert(t1:TransformVector(Vector3(0, 0, 1)):IsClose(Vector3(0, 0, 3)))"); + script->Execute("AZTestAssert(t1:TransformVector(Vector3(0, 0, 1)):IsClose(Vector3(0, 0, 2)))"); script->Execute("t1 = Transform.CreateTranslation(Vector3(1, 2, 3))"); script->Execute("AZTestAssert(t1:TransformVector(Vector3(1, 0, 0)):IsClose(Vector3(1, 0, 0)))"); script->Execute("AZTestAssert(t1:TransformVector(Vector3(0, 1, 0)):IsClose(Vector3(0, 1, 0)))"); @@ -1341,19 +1341,19 @@ namespace UnitTest script->Execute("AZTestAssert(t3:GetTranslation():IsClose(Vector3(-5.90, 25.415, 19.645), 0.001))"); ////test inverse, should handle non-orthogonal matrices - script->Execute("t1 = Transform.CreateRotationX(1) * Transform.CreateScale(Vector3(1, 2, 3))"); + script->Execute("t1 = Transform.CreateRotationX(1) * Transform.CreateUniformScale(2)"); script->Execute("AZTestAssert((t1*t1:GetInverse()):IsClose(Transform.CreateIdentity()))"); ////scale access - script->Execute("t1 = Transform.CreateRotationX(Math.DegToRad(40)) * Transform.CreateScale(Vector3(2, 3, 4))"); - script->Execute("AZTestAssert(t1:GetScale():IsClose(Vector3(2, 3, 4)))"); - script->Execute("AZTestAssert(t1:ExtractScale():IsClose(Vector3(2, 3, 4)))"); - script->Execute("AZTestAssert(t1:GetScale():IsClose(Vector3.CreateOne()))"); - script->Execute("t1:MultiplyByScale(Vector3(3, 4, 5))"); - script->Execute("AZTestAssert(t1:GetScale():IsClose(Vector3(3, 4, 5)))"); + script->Execute("t1 = Transform.CreateRotationX(Math.DegToRad(40)) * Transform.CreateUniformScale(3)"); + script->Execute("AZTestAssertFloatClose(t1:GetUniformScale(), 3)"); + script->Execute("AZTestAssertFloatClose(t1:ExtractUniformScale(), 3)"); + script->Execute("AZTestAssertFloatClose(t1:GetUniformScale(), 1)"); + script->Execute("t1:MultiplyByUniformScale(2)"); + script->Execute("AZTestAssertFloatClose(t1:GetUniformScale(), 2)"); ////orthogonalize - script->Execute("t1 = Transform.CreateRotationX(Math.DegToRad(30)) * Transform.CreateScale(Vector3(2, 3, 4))"); + script->Execute("t1 = Transform.CreateRotationX(Math.DegToRad(30)) * Transform.CreateUniformScale(3)"); script->Execute("t1:SetTranslation(Vector3(1,2,3))"); script->Execute("t2 = t1:GetOrthogonalized()"); script->Execute("AZTestAssertFloatClose(t2:GetBasisX():GetLength(), 1)"); @@ -1372,7 +1372,7 @@ namespace UnitTest script->Execute("t1 = Transform.CreateRotationX(Math.DegToRad(30))"); script->Execute("t1:SetTranslation(Vector3(1, 2, 3))"); script->Execute("AZTestAssert(t1:IsOrthogonal(0.05))"); - script->Execute("t1 = Transform.CreateRotationX(Math.DegToRad(30)) * Transform.CreateScale(Vector3(2, 3, 4))"); + script->Execute("t1 = Transform.CreateRotationX(Math.DegToRad(30)) * Transform.CreateUniformScale(2)"); script->Execute("AZTestAssert( not t1:IsOrthogonal(0.05))"); ////IsClose diff --git a/Code/Framework/AzCore/Tests/Serialization/Json/TransformSerializerTests.cpp b/Code/Framework/AzCore/Tests/Serialization/Json/TransformSerializerTests.cpp index 12711b1e1a..e1e9bd237d 100644 --- a/Code/Framework/AzCore/Tests/Serialization/Json/TransformSerializerTests.cpp +++ b/Code/Framework/AzCore/Tests/Serialization/Json/TransformSerializerTests.cpp @@ -189,7 +189,7 @@ namespace JsonSerializationTests TEST_F(JsonTransformSerializerTests, Load_FullySetTransform_ReturnsSuccessWithOnlyScale) { AZ::Transform testTransform = AZ::Transform::CreateIdentity(); - AZ::Transform expectedTransform = AZ::Transform::CreateScale(AZ::Vector3(5.5f)); + AZ::Transform expectedTransform = AZ::Transform::CreateUniformScale(5.5f); rapidjson::Document json; json.Parse(R"({ "Scale" : 5.5 })"); diff --git a/Code/Framework/AzFramework/AzFramework/Components/TransformComponent.cpp b/Code/Framework/AzFramework/AzFramework/Components/TransformComponent.cpp index 9083cb7d0d..3dafc7c717 100644 --- a/Code/Framework/AzFramework/AzFramework/Components/TransformComponent.cpp +++ b/Code/Framework/AzFramework/AzFramework/Components/TransformComponent.cpp @@ -432,46 +432,26 @@ namespace AzFramework void TransformComponent::SetLocalRotation(const AZ::Vector3& eulerRadianAngles) { - AZ::Transform newLocalTM = AZ::ConvertEulerRadiansToTransform(eulerRadianAngles); - newLocalTM.SetScale(m_localTM.GetScale()); - newLocalTM.SetTranslation(m_localTM.GetTranslation()); + AZ::Transform newLocalTM = m_localTM; + newLocalTM.SetRotation(AZ::Quaternion::CreateFromEulerAnglesRadians(eulerRadianAngles)); SetLocalTM(newLocalTM); } void TransformComponent::SetLocalRotationQuaternion(const AZ::Quaternion& quaternion) { - AZ::Transform newLocalTM; - newLocalTM.SetScale(m_localTM.GetScale()); - newLocalTM.SetTranslation(m_localTM.GetTranslation()); + AZ::Transform newLocalTM = m_localTM; newLocalTM.SetRotation(quaternion); SetLocalTM(newLocalTM); } static AZ::Transform RotateAroundLocalHelper(float eulerAngleRadian, const AZ::Transform& localTM, AZ::Vector3 axis) { - //get the existing translation and scale - AZ::Vector3 translation = localTM.GetTranslation(); - AZ::Vector3 scale = localTM.GetScale(); - //normalize the axis before creating rotation axis.Normalize(); AZ::Quaternion rotate = AZ::Quaternion::CreateFromAxisAngle(axis, eulerAngleRadian); - //create new rotation transform - AZ::Quaternion currentRotate = localTM.GetRotation(); - AZ::Quaternion newRotate = rotate * currentRotate; - newRotate.Normalize(); - - //scale - AZ::Transform newLocalTM = AZ::Transform::CreateScale(scale); - - //rotate - AZ::Transform rotateLocalTM = AZ::Transform::CreateFromQuaternion(newRotate); - newLocalTM = rotateLocalTM * newLocalTM; - - //translate - newLocalTM.SetTranslation(translation); - + AZ::Transform newLocalTM = localTM; + newLocalTM.SetRotation((rotate * localTM.GetRotation()).GetNormalized()); return newLocalTM; } @@ -512,75 +492,6 @@ namespace AzFramework return m_localTM.GetRotation(); } - void TransformComponent::SetScale(const AZ::Vector3& scale) - { - AZ_Warning("TransformComponent", false, "SetScale is deprecated, please use SetLocalScale"); - - if (!m_worldTM.GetScale().IsClose(scale)) - { - AZ::Transform newWorldTransform = m_worldTM; - newWorldTransform.SetScale(scale); - SetWorldTM(newWorldTransform); - } - } - - void TransformComponent::SetScaleX(float scaleX) - { - AZ_Warning("TransformComponent", false, "SetScaleX is deprecated, please use SetLocalScaleX"); - - AZ::Vector3 newScale = m_worldTM.GetScale(); - newScale.SetX(scaleX); - AZ::Transform newWorldTransform = m_worldTM; - newWorldTransform.SetScale(newScale); - SetWorldTM(newWorldTransform); - } - - void TransformComponent::SetScaleY(float scaleY) - { - AZ_Warning("TransformComponent", false, "SetScaleY is deprecated, please use SetLocalScaleY"); - - AZ::Vector3 newScale = m_worldTM.GetScale(); - newScale.SetY(scaleY); - AZ::Transform newWorldTransform = m_worldTM; - newWorldTransform.SetScale(newScale); - SetWorldTM(newWorldTransform); - } - - void TransformComponent::SetScaleZ(float scaleZ) - { - AZ_Warning("TransformComponent", false, "SetScaleZ is deprecated, please use SetLocalScaleZ"); - - AZ::Vector3 newScale = m_worldTM.GetScale(); - newScale.SetZ(scaleZ); - AZ::Transform newWorldTransform = m_worldTM; - newWorldTransform.SetScale(newScale); - SetWorldTM(newWorldTransform); - } - - AZ::Vector3 TransformComponent::GetScale() - { - AZ_Warning("TransformComponent", false, "GetScale is deprecated, please use GetLocalScale"); - return m_worldTM.GetScale(); - } - - float TransformComponent::GetScaleX() - { - AZ_Warning("TransformComponent", false, "GetScaleX is deprecated, please use GetLocalScale"); - return m_worldTM.GetScale().GetX(); - } - - float TransformComponent::GetScaleY() - { - AZ_Warning("TransformComponent", false, "GetScaleY is deprecated, please use GetLocalScale"); - return m_worldTM.GetScale().GetY(); - } - - float TransformComponent::GetScaleZ() - { - AZ_Warning("TransformComponent", false, "GetScaleZ is deprecated, please use GetLocalScale"); - return m_worldTM.GetScale().GetZ(); - } - void TransformComponent::SetLocalScale(const AZ::Vector3& scale) { AZ::Transform newLocalTM = m_localTM; @@ -588,33 +499,6 @@ namespace AzFramework SetLocalTM(newLocalTM); } - void TransformComponent::SetLocalScaleX(float scaleX) - { - AZ::Transform newLocalTM = m_localTM; - AZ::Vector3 newScale = newLocalTM.GetScale(); - newScale.SetX(scaleX); - newLocalTM.SetScale(newScale); - SetLocalTM(newLocalTM); - } - - void TransformComponent::SetLocalScaleY(float scaleY) - { - AZ::Transform newLocalTM = m_localTM; - AZ::Vector3 newScale = newLocalTM.GetScale(); - newScale.SetY(scaleY); - newLocalTM.SetScale(newScale); - SetLocalTM(newLocalTM); - } - - void TransformComponent::SetLocalScaleZ(float scaleZ) - { - AZ::Transform newLocalTM = m_localTM; - AZ::Vector3 newScale = newLocalTM.GetScale(); - newScale.SetZ(scaleZ); - newLocalTM.SetScale(newScale); - SetLocalTM(newLocalTM); - } - AZ::Vector3 TransformComponent::GetLocalScale() { return m_localTM.GetScale(); @@ -625,6 +509,23 @@ namespace AzFramework return m_worldTM.GetScale(); } + void TransformComponent::SetLocalUniformScale(float scale) + { + AZ::Transform newLocalTM = m_localTM; + newLocalTM.SetUniformScale(scale); + SetLocalTM(newLocalTM); + } + + float TransformComponent::GetLocalUniformScale() + { + return m_localTM.GetUniformScale(); + } + + float TransformComponent::GetWorldUniformScale() + { + return m_worldTM.GetUniformScale(); + } + AZStd::vector TransformComponent::GetChildren() { AZStd::vector children; @@ -979,34 +880,7 @@ namespace AzFramework ->Event("GetLocalRotationQuaternion", &AZ::TransformBus::Events::GetLocalRotationQuaternion) ->Attribute("Rotation", AZ::Edit::Attributes::PropertyRotation) ->VirtualProperty("Rotation", "GetLocalRotationQuaternion", "SetLocalRotationQuaternion") - ->Event("SetScale", &AZ::TransformBus::Events::SetScale) - ->Attribute(AZ::Script::Attributes::Deprecated, true) - ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All) - ->Event("SetScaleX", &AZ::TransformBus::Events::SetScaleX) - ->Attribute(AZ::Script::Attributes::Deprecated, true) - ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All) - ->Event("SetScaleY", &AZ::TransformBus::Events::SetScaleY) - ->Attribute(AZ::Script::Attributes::Deprecated, true) - ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All) - ->Event("SetScaleZ", &AZ::TransformBus::Events::SetScaleZ) - ->Attribute(AZ::Script::Attributes::Deprecated, true) - ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All) - ->Event("GetScale", &AZ::TransformBus::Events::GetScale) - ->Attribute(AZ::Script::Attributes::Deprecated, true) - ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All) - ->Event("GetScaleX", &AZ::TransformBus::Events::GetScaleX) - ->Attribute(AZ::Script::Attributes::Deprecated, true) - ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All) - ->Event("GetScaleY", &AZ::TransformBus::Events::GetScaleY) - ->Attribute(AZ::Script::Attributes::Deprecated, true) - ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All) - ->Event("GetScaleZ", &AZ::TransformBus::Events::GetScaleZ) - ->Attribute(AZ::Script::Attributes::Deprecated, true) - ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All) ->Event("SetLocalScale", &AZ::TransformBus::Events::SetLocalScale) - ->Event("SetLocalScaleX", &AZ::TransformBus::Events::SetLocalScaleX) - ->Event("SetLocalScaleY", &AZ::TransformBus::Events::SetLocalScaleY) - ->Event("SetLocalScaleZ", &AZ::TransformBus::Events::SetLocalScaleZ) ->Event("GetLocalScale", &AZ::TransformBus::Events::GetLocalScale) ->Attribute("Scale", AZ::Edit::Attributes::PropertyScale) ->VirtualProperty("Scale", "GetLocalScale", "SetLocalScale") diff --git a/Code/Framework/AzFramework/AzFramework/Components/TransformComponent.h b/Code/Framework/AzFramework/AzFramework/Components/TransformComponent.h index 0dd53d84ed..e3a647d39f 100644 --- a/Code/Framework/AzFramework/AzFramework/Components/TransformComponent.h +++ b/Code/Framework/AzFramework/AzFramework/Components/TransformComponent.h @@ -143,24 +143,14 @@ namespace AzFramework AZ::Quaternion GetLocalRotationQuaternion() override; // Scale Modifiers - void SetScale(const AZ::Vector3& scale) override; - void SetScaleX(float scaleX) override; - void SetScaleY(float scaleY) override; - void SetScaleZ(float scaleZ) override; - - AZ::Vector3 GetScale() override; - float GetScaleX() override; - float GetScaleY() override; - float GetScaleZ() override; - void SetLocalScale(const AZ::Vector3& scale) override; - void SetLocalScaleX(float scaleX) override; - void SetLocalScaleY(float scaleY) override; - void SetLocalScaleZ(float scaleZ) override; - AZ::Vector3 GetLocalScale() override; AZ::Vector3 GetWorldScale() override; + void SetLocalUniformScale(float scale) override; + float GetLocalUniformScale() override; + float GetWorldUniformScale() override; + // Transform hierarchy AZStd::vector GetChildren() override; AZStd::vector GetAllDescendants() override; diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ScaleManipulators.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ScaleManipulators.cpp index 3af09f644d..caeedd834f 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ScaleManipulators.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ScaleManipulators.cpp @@ -82,9 +82,7 @@ namespace AzToolsFramework m_uniformScaleManipulator->SetVisualOrientationOverride( QuaternionFromTransformNoScaling(localTransform)); - m_uniformScaleManipulator->SetLocalTransform( - AZ::Transform::CreateTranslation(localTransform.GetTranslation()) * - AZ::Transform::CreateScale(localTransform.GetScale())); + m_uniformScaleManipulator->SetLocalOrientation(AZ::Quaternion::CreateIdentity()); } void ScaleManipulators::SetLocalPositionImpl(const AZ::Vector3& localPosition) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Maths/TransformUtils.h b/Code/Framework/AzToolsFramework/AzToolsFramework/Maths/TransformUtils.h index 247be33839..97add27604 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/Maths/TransformUtils.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Maths/TransformUtils.h @@ -33,8 +33,7 @@ namespace AzToolsFramework inline AZ::Transform TransformUniformScale(const AZ::Transform& transform) { AZ::Transform transformUniformScale = transform; - const float maxScale = transformUniformScale.GetScale().GetMaxElement(); - transformUniformScale.SetScale(AZ::Vector3(maxScale)); + transformUniformScale.SetUniformScale(transformUniformScale.GetUniformScale()); return transformUniformScale; } diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Slice/SliceUtilities.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Slice/SliceUtilities.cpp index 4b73166b3d..38a6156ec5 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/Slice/SliceUtilities.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Slice/SliceUtilities.cpp @@ -1475,10 +1475,8 @@ namespace AzToolsFramework // to avoid pushing them to the slice. // Only scale is preserved on the root entity of a slice. transformComponent->SetParent(AZ::EntityId()); - AZ::Vector3 scale = transformComponent->GetLocalScale(); transformComponent->SetWorldTranslation(AZ::Vector3::CreateZero()); transformComponent->SetLocalRotation(AZ::Vector3::CreateZero()); - transformComponent->SetLocalScale(scale); } } diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponent.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponent.cpp index 519b6d0b26..b73978c792 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponent.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponent.cpp @@ -357,7 +357,7 @@ namespace AzToolsFramework AZ::Transform TransformComponent::GetLocalScaleTM() const { - return AZ::Transform::CreateScale(m_editorTransform.m_scale); + return AZ::Transform::CreateUniformScale(m_editorTransform.m_scale.GetMaxElement()); } const AZ::Transform& TransformComponent::GetLocalTM() @@ -677,100 +677,12 @@ namespace AzToolsFramework return result; } - void TransformComponent::SetScale(const AZ::Vector3& newScale) - { - AZ_Warning("AzToolsFramework::TransformComponent", false, "SetScale is deprecated, please use SetLocalScale"); - - AZ::Transform newWorldTransform = GetWorldTM(); - AZ::Vector3 prevScale = newWorldTransform.ExtractScale(); - if (!prevScale.IsClose(newScale)) - { - newWorldTransform.MultiplyByScale(newScale); - SetWorldTM(newWorldTransform); - } - } - - void TransformComponent::SetScaleX(float newScale) - { - AZ_Warning("AzToolsFramework::TransformComponent", false, "SetScaleX is deprecated, please use SetLocalScaleX"); - - AZ::Transform newWorldTransform = GetWorldTM(); - AZ::Vector3 scale = newWorldTransform.ExtractScale(); - scale.SetX(newScale); - newWorldTransform.MultiplyByScale(scale); - SetWorldTM(newWorldTransform); - } - - void TransformComponent::SetScaleY(float newScale) - { - AZ_Warning("AzToolsFramework::TransformComponent", false, "SetScaleY is deprecated, please use SetLocalScaleY"); - - AZ::Transform newWorldTransform = GetWorldTM(); - AZ::Vector3 scale = newWorldTransform.ExtractScale(); - scale.SetY(newScale); - newWorldTransform.MultiplyByScale(scale); - SetWorldTM(newWorldTransform); - } - - void TransformComponent::SetScaleZ(float newScale) - { - AZ_Warning("AzToolsFramework::TransformComponent", false, "SetScaleZ is deprecated, please use SetLocalScaleZ"); - - AZ::Transform newWorldTransform = GetWorldTM(); - AZ::Vector3 scale = newWorldTransform.ExtractScale(); - scale.SetZ(newScale); - newWorldTransform.MultiplyByScale(scale); - SetWorldTM(newWorldTransform); - } - - AZ::Vector3 TransformComponent::GetScale() - { - AZ_Warning("AzToolsFramework::TransformComponent", false, "GetScale is deprecated, please use GetLocalScale"); - return GetWorldTM().GetScale(); - } - - float TransformComponent::GetScaleX() - { - AZ_Warning("AzToolsFramework::TransformComponent", false, "GetScaleX is deprecated, please use GetLocalScale"); - return GetWorldTM().GetScale().GetX(); - } - - float TransformComponent::GetScaleY() - { - AZ_Warning("AzToolsFramework::TransformComponent", false, "GetScaleY is deprecated, please use GetLocalScale"); - return GetWorldTM().GetScale().GetY(); - } - - float TransformComponent::GetScaleZ() - { - AZ_Warning("AzToolsFramework::TransformComponent", false, "GetScaleZ is deprecated, please use GetLocalScale"); - return GetWorldTM().GetScale().GetZ(); - } - void TransformComponent::SetLocalScale(const AZ::Vector3& scale) { m_editorTransform.m_scale = scale; TransformChanged(); } - void TransformComponent::SetLocalScaleX(float scaleX) - { - m_editorTransform.m_scale.SetX(scaleX); - TransformChanged(); - } - - void TransformComponent::SetLocalScaleY(float scaleY) - { - m_editorTransform.m_scale.SetY(scaleY); - TransformChanged(); - } - - void TransformComponent::SetLocalScaleZ(float scaleZ) - { - m_editorTransform.m_scale.SetZ(scaleZ); - TransformChanged(); - } - AZ::Vector3 TransformComponent::GetLocalScale() { return m_editorTransform.m_scale; @@ -781,6 +693,22 @@ namespace AzToolsFramework return GetWorldTM().GetScale(); } + void TransformComponent::SetLocalUniformScale(float scale) + { + m_editorTransform.m_scale = AZ::Vector3(scale); + TransformChanged(); + } + + float TransformComponent::GetLocalUniformScale() + { + return m_editorTransform.m_scale.GetMaxElement(); + } + + float TransformComponent::GetWorldUniformScale() + { + return GetWorldTM().GetUniformScale(); + } + const AZ::Transform& TransformComponent::GetParentWorldTM() const { auto parent = GetParentTransformComponent(); @@ -1183,12 +1111,6 @@ namespace AzToolsFramework ModifyEditorTransform(m_editorTransform.m_rotate, data, parent); } - void TransformComponent::ScaleBy(const AZ::Vector3& data) - { - //scale is always local - ModifyEditorTransform(m_editorTransform.m_scale, data, AZ::Transform::Identity()); - } - AZ::EntityId TransformComponent::GetSliceEntityParentId() { return GetParentId(); diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponent.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponent.h index 3d1e1ed672..91d64b0533 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponent.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponent.h @@ -130,24 +130,14 @@ namespace AzToolsFramework AZ::Quaternion GetLocalRotationQuaternion() override; // Scale Modifiers - void SetScale(const AZ::Vector3& newScale) override; - void SetScaleX(float newScale) override; - void SetScaleY(float newScale) override; - void SetScaleZ(float newScale) override; - - AZ::Vector3 GetScale() override; - float GetScaleX() override; - float GetScaleY() override; - float GetScaleZ() override; - void SetLocalScale(const AZ::Vector3& scale) override; - void SetLocalScaleX(float scaleX) override; - void SetLocalScaleY(float scaleY) override; - void SetLocalScaleZ(float scaleZ) override; - AZ::Vector3 GetLocalScale() override; AZ::Vector3 GetWorldScale() override; + void SetLocalUniformScale(float scale) override; + float GetLocalUniformScale() override; + float GetWorldUniformScale() override; + AZ::EntityId GetParentId() override; AZ::TransformInterface* GetParent() override; void SetParent(AZ::EntityId parentId) override; @@ -161,7 +151,6 @@ namespace AzToolsFramework // TransformComponentMessages::Bus void TranslateBy(const AZ::Vector3&) override; void RotateBy(const AZ::Vector3&) override; // euler in degrees - void ScaleBy(const AZ::Vector3&) override; const EditorTransform& GetLocalEditorTransform() override; void SetLocalEditorTransform(const EditorTransform& dest) override; bool IsTransformLocked() override; diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponentBus.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponentBus.h index f1cb8459c4..437a39b1a0 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponentBus.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponentBus.h @@ -65,7 +65,6 @@ namespace AzToolsFramework virtual void TranslateBy(const AZ::Vector3&) = 0; virtual void RotateBy(const AZ::Vector3&) = 0; - virtual void ScaleBy(const AZ::Vector3&) = 0; virtual bool IsTransformLocked() = 0; }; diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.cpp index 91644dc6ac..86744ab16d 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.cpp +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.cpp @@ -1474,7 +1474,7 @@ namespace AzToolsFramework { const AZ::Quaternion rotation = entityIdLookupIt->second.m_initial.GetRotation().GetNormalized(); const AZ::Vector3 position = entityIdLookupIt->second.m_initial.GetTranslation(); - const AZ::Vector3 scale = entityIdLookupIt->second.m_initial.GetScale(); + const float scale = entityIdLookupIt->second.m_initial.GetUniformScale(); const AZ::Vector3 centerOffset = CalculateCenterOffset(entityId, m_pivotMode); @@ -1485,7 +1485,7 @@ namespace AzToolsFramework AZ::Transform::CreateFromQuaternion(rotation) * AZ::Transform::CreateTranslation(centerOffset) * offsetRotation * AZ::Transform::CreateTranslation(-centerOffset) * - AZ::Transform::CreateScale(scale)); + AZ::Transform::CreateUniformScale(scale)); } break; case ReferenceFrame::Parent: @@ -1597,16 +1597,15 @@ namespace AzToolsFramework } const AZ::Transform initial = entityIdLookupIt->second.m_initial; - const AZ::Vector3 initialScale = initial.GetScale(); + const float initialScale = initial.GetUniformScale(); const auto sumVectorElements = [](const AZ::Vector3& vec) { return vec.GetX() + vec.GetY() + vec.GetZ(); }; - const AZ::Vector3 uniformScale = AZ::Vector3(action.m_start.m_sign * sumVectorElements(action.LocalScaleOffset())); - const AZ::Vector3 scale = (AZ::Vector3::CreateOne() + - (uniformScale / initialScale)).GetClamp(AZ::Vector3(AZ::MinTransformScale), AZ::Vector3(AZ::MaxTransformScale)); - const AZ::Transform scaleTransform = AZ::Transform::CreateScale(scale); + const float uniformScale = action.m_start.m_sign * sumVectorElements(action.LocalScaleOffset()); + const float scale = AZ::GetClamp(1.0f + uniformScale / initialScale, AZ::MinTransformScale, AZ::MaxTransformScale); + const AZ::Transform scaleTransform = AZ::Transform::CreateUniformScale(scale); if (action.m_modifiers.Alt()) { @@ -1872,7 +1871,7 @@ namespace AzToolsFramework CopyOrientationToSelectedEntitiesGroup(QuaternionFromTransformNoScaling(worldFromLocal)); break; case Mode::Scale: - CopyScaleToSelectedEntitiesIndividualWorld(worldFromLocal.GetScale()); + CopyScaleToSelectedEntitiesIndividualWorld(worldFromLocal.GetUniformScale()); break; case Mode::Translation: CopyTranslationToSelectedEntitiesGroup(worldFromLocal.GetTranslation()); @@ -1901,7 +1900,7 @@ namespace AzToolsFramework CopyOrientationToSelectedEntitiesIndividual(QuaternionFromTransformNoScaling(worldFromLocal)); break; case Mode::Scale: - CopyScaleToSelectedEntitiesIndividualWorld(worldFromLocal.GetScale()); + CopyScaleToSelectedEntitiesIndividualWorld(worldFromLocal.GetUniformScale()); break; case Mode::Translation: CopyTranslationToSelectedEntitiesIndividual(worldFromLocal.GetTranslation()); @@ -2394,7 +2393,7 @@ namespace AzToolsFramework ResetOrientationForSelectedEntitiesLocal(); break; case Mode::Scale: - CopyScaleToSelectedEntitiesIndividualLocal(AZ::Vector3::CreateOne()); + CopyScaleToSelectedEntitiesIndividualLocal(1.0f); break; case Mode::Translation: ResetTranslationForSelectedEntitiesLocal(); @@ -2420,7 +2419,7 @@ namespace AzToolsFramework ResetOrientationForSelectedEntitiesLocal(); break; case Mode::Scale: - CopyScaleToSelectedEntitiesIndividualWorld(AZ::Vector3::CreateOne()); + CopyScaleToSelectedEntitiesIndividualWorld(1.0f); break; case Mode::Translation: // do nothing @@ -2940,7 +2939,7 @@ namespace AzToolsFramework } } - void EditorTransformComponentSelection::CopyScaleToSelectedEntitiesIndividualWorld(const AZ::Vector3& scale) + void EditorTransformComponentSelection::CopyScaleToSelectedEntitiesIndividualWorld(float scale) { AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework); @@ -2955,7 +2954,7 @@ namespace AzToolsFramework const auto transformsBefore = RecordTransformsBefore(manipulatorEntityIds.m_entityIds); // update scale relative to initial - const AZ::Transform scaleTransform = AZ::Transform::CreateScale(scale); + const AZ::Transform scaleTransform = AZ::Transform::CreateUniformScale(scale); for (AZ::EntityId entityId : manipulatorEntityIds.m_entityIds) { ScopedUndoBatch::MarkEntityDirty(entityId); @@ -2974,7 +2973,7 @@ namespace AzToolsFramework RefreshUiAfterChange(manipulatorEntityIds.m_entityIds); } - void EditorTransformComponentSelection::CopyScaleToSelectedEntitiesIndividualLocal(const AZ::Vector3& scale) + void EditorTransformComponentSelection::CopyScaleToSelectedEntitiesIndividualLocal(float scale) { AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework); @@ -3020,9 +3019,9 @@ namespace AzToolsFramework if (transformIt != transformsBefore.end()) { AZ::Transform newWorldFromLocal = transformIt->second; - const AZ::Vector3 scale = newWorldFromLocal.GetScale(); + const float scale = newWorldFromLocal.GetUniformScale(); newWorldFromLocal.SetRotation(orientation); - newWorldFromLocal *= AZ::Transform::CreateScale(scale); + newWorldFromLocal *= AZ::Transform::CreateUniformScale(scale); SetEntityWorldTransform(entityId, newWorldFromLocal); } @@ -3669,7 +3668,7 @@ namespace AzToolsFramework } void EditorTransformComponentSelection::SetEntityLocalScale( - const AZ::EntityId entityId, const AZ::Vector3& localScale) + const AZ::EntityId entityId, const float localScale) { ETCS::SetEntityLocalScale(entityId, localScale, m_transformChangedInternally); } @@ -3722,11 +3721,11 @@ namespace AzToolsFramework entityId, &AZ::TransformBus::Events::SetWorldTM, worldTransform); } - void SetEntityLocalScale(AZ::EntityId entityId, const AZ::Vector3& localScale, bool& internal) + void SetEntityLocalScale(AZ::EntityId entityId, float localScale, bool& internal) { ScopeSwitch sw(internal); AZ::TransformBus::Event( - entityId, &AZ::TransformBus::Events::SetLocalScale, localScale); + entityId, &AZ::TransformBus::Events::SetLocalUniformScale, localScale); } void SetEntityLocalRotation(AZ::EntityId entityId, const AZ::Vector3& localRotation, bool& internal) diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.h index 7514f5153b..500ae484f8 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.h @@ -214,8 +214,8 @@ namespace AzToolsFramework void CopyOrientationToSelectedEntitiesIndividual(const AZ::Quaternion& orientation); void CopyOrientationToSelectedEntitiesGroup(const AZ::Quaternion& orientation); void ResetOrientationForSelectedEntitiesLocal(); - void CopyScaleToSelectedEntitiesIndividualLocal(const AZ::Vector3& scale); - void CopyScaleToSelectedEntitiesIndividualWorld(const AZ::Vector3& scale); + void CopyScaleToSelectedEntitiesIndividualLocal(float scale); + void CopyScaleToSelectedEntitiesIndividualWorld(float scale); // EditorManipulatorCommandUndoRedoRequestBus ... void UndoRedoEntityManipulatorCommand( @@ -250,7 +250,7 @@ namespace AzToolsFramework void SetEntityWorldTranslation(AZ::EntityId entityId, const AZ::Vector3& worldTranslation); void SetEntityLocalTranslation(AZ::EntityId entityId, const AZ::Vector3& localTranslation); void SetEntityWorldTransform(AZ::EntityId entityId, const AZ::Transform& worldTransform); - void SetEntityLocalScale(AZ::EntityId entityId, const AZ::Vector3& localScale); + void SetEntityLocalScale(AZ::EntityId entityId, float localScale); void SetEntityLocalRotation(AZ::EntityId entityId, const AZ::Vector3& localRotation); AZ::EntityId m_hoveredEntityId; //!< What EntityId is the mouse currently hovering over (if any). @@ -320,7 +320,7 @@ namespace AzToolsFramework void SetEntityWorldTranslation(AZ::EntityId entityId, const AZ::Vector3& worldTranslation, bool& internal); void SetEntityLocalTranslation(AZ::EntityId entityId, const AZ::Vector3& localTranslation, bool& internal); void SetEntityWorldTransform(AZ::EntityId entityId, const AZ::Transform& worldTransform, bool& internal); - void SetEntityLocalScale(AZ::EntityId entityId, const AZ::Vector3& localScale, bool& internal); + void SetEntityLocalScale(AZ::EntityId entityId, float localScale, bool& internal); void SetEntityLocalRotation(AZ::EntityId entityId, const AZ::Vector3& localRotation, bool& internal); } // namespace ETCS } // namespace AzToolsFramework diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelectionRequestBus.h b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelectionRequestBus.h index 59c250b8f7..9cd78f8c50 100644 --- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelectionRequestBus.h +++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelectionRequestBus.h @@ -101,10 +101,10 @@ namespace AzToolsFramework virtual void ResetOrientationForSelectedEntitiesLocal() = 0; /// Copy scale to each individual entity in local space without moving position. - virtual void CopyScaleToSelectedEntitiesIndividualLocal(const AZ::Vector3& scale) = 0; + virtual void CopyScaleToSelectedEntitiesIndividualLocal(float scale) = 0; /// Copy scale to to each individual entity in world (absolute) space. - virtual void CopyScaleToSelectedEntitiesIndividualWorld(const AZ::Vector3& scale) = 0; + virtual void CopyScaleToSelectedEntitiesIndividualWorld(float scale) = 0; protected: ~EditorTransformComponentSelectionRequests() = default; diff --git a/Code/Framework/AzToolsFramework/Tests/Slice.cpp b/Code/Framework/AzToolsFramework/Tests/Slice.cpp index 33160b9c20..7b67481684 100644 --- a/Code/Framework/AzToolsFramework/Tests/Slice.cpp +++ b/Code/Framework/AzToolsFramework/Tests/Slice.cpp @@ -483,6 +483,9 @@ namespace UnitTest { AUTO_RESULT_IF_SETTING_TRUE(UnitTest::prefabSystemSetting, true) + // Swallow deprecation warnings from the Transform component as they are not relevant to this test + UnitTest::ErrorHandler errorHandler("GetScale is deprecated"); + // Create a parent entity with a transform component AZ::Entity* parentEntity = aznew AZ::Entity("TestParentEntity"); parentEntity->CreateComponent(); diff --git a/Code/Framework/AzToolsFramework/Tests/ToolsComponents/EditorLayerComponentTests.cpp b/Code/Framework/AzToolsFramework/Tests/ToolsComponents/EditorLayerComponentTests.cpp index 7b03b63dd0..2177b9e1b2 100644 --- a/Code/Framework/AzToolsFramework/Tests/ToolsComponents/EditorLayerComponentTests.cpp +++ b/Code/Framework/AzToolsFramework/Tests/ToolsComponents/EditorLayerComponentTests.cpp @@ -610,15 +610,15 @@ namespace AzToolsFramework m_layerEntity.m_layer->ClearUnsavedChanges(); // Change the scale of the child entity so it registers as an unsaved change on the layer. - AZ::Vector3 scale(-1.0f,0.0f,0.0f); + float scale = 0.0f; AZ::TransformBus::EventResult( scale, childEntity->GetId(), - &AZ::TransformBus::Events::GetLocalScale); - scale.SetX(scale.GetX() + 1.0f); + &AZ::TransformBus::Events::GetLocalUniformScale); + scale += 1.0f; AZ::TransformBus::Event( childEntity->GetId(), - &AZ::TransformBus::Events::SetLocalScale, + &AZ::TransformBus::Events::SetLocalUniformScale, scale); bool hasUnsavedChanges = false; diff --git a/Code/Framework/AzToolsFramework/Tests/ToolsComponents/EditorTransformComponentTests.cpp b/Code/Framework/AzToolsFramework/Tests/ToolsComponents/EditorTransformComponentTests.cpp index 62cf16f9a7..fcc4aa49e5 100644 --- a/Code/Framework/AzToolsFramework/Tests/ToolsComponents/EditorTransformComponentTests.cpp +++ b/Code/Framework/AzToolsFramework/Tests/ToolsComponents/EditorTransformComponentTests.cpp @@ -52,19 +52,19 @@ namespace AzToolsFramework TransformTestEntityHierarchy hierarchy = BuildTestHierarchy(); // Set scale to parent entity - const AZ::Vector3 parentScale(2.0f, 1.0f, 3.0f); - AZ::TransformBus::Event(hierarchy.m_parentId, &AZ::TransformInterface::SetLocalScale, parentScale); + const float parentScale = 2.0f; + AZ::TransformBus::Event(hierarchy.m_parentId, &AZ::TransformInterface::SetLocalUniformScale, parentScale); // Set scale to child entity - const AZ::Vector3 childScale(5.0f, 6.0f, 10.0f); - AZ::TransformBus::Event(hierarchy.m_childId, &AZ::TransformInterface::SetLocalScale, childScale); + const float childScale = 5.0f; + AZ::TransformBus::Event(hierarchy.m_childId, &AZ::TransformInterface::SetLocalUniformScale, childScale); - const AZ::Vector3 expectedScale = childScale * parentScale; + const float expectedScale = childScale * parentScale; - AZ::Vector3 childWorldScale = AZ::Vector3::CreateOne(); - AZ::TransformBus::EventResult(childWorldScale, hierarchy.m_childId, &AZ::TransformBus::Events::GetWorldScale); + float childWorldScale = 1.0f; + AZ::TransformBus::EventResult(childWorldScale, hierarchy.m_childId, &AZ::TransformBus::Events::GetWorldUniformScale); - EXPECT_THAT(childWorldScale, UnitTest::IsClose(expectedScale)); + EXPECT_NEAR(childWorldScale, expectedScale, AZ::Constants::Tolerance); } TEST_F(EditorTransformComponentTest, TransformTests_GetChildren_DirectChildrenMatchHierarchy) diff --git a/Code/Framework/Tests/TransformComponent.cpp b/Code/Framework/Tests/TransformComponent.cpp index c2615f2a30..707c4d66ec 100644 --- a/Code/Framework/Tests/TransformComponent.cpp +++ b/Code/Framework/Tests/TransformComponent.cpp @@ -24,6 +24,8 @@ #include #include +#include + using namespace AZ; using namespace AzFramework; @@ -362,8 +364,8 @@ namespace UnitTest TEST_F(TransformComponentTransformMatrixSetGet, SetLocalRotation_SimpleValues_Set) { // add some scale first - float sx = 1.03f, sy = 0.67f, sz = 1.23f; - Transform tm = Transform::CreateScale(Vector3(sx, sy, sz)); + float scale = 1.23f; + Transform tm = Transform::CreateUniformScale(scale); TransformBus::Event(m_childId, &TransformBus::Events::SetLocalTM, tm); float rx = 42.435f; @@ -379,13 +381,13 @@ namespace UnitTest Matrix3x3 finalRotate = rotateX * rotateY * rotateZ; Vector3 basisX = tm.GetBasisX(); - Vector3 expectedBasisX = finalRotate.GetBasisX() * sx; + Vector3 expectedBasisX = finalRotate.GetBasisX() * scale; EXPECT_TRUE(basisX.IsClose(expectedBasisX)); Vector3 basisY = tm.GetBasisY(); - Vector3 expectedBasisY = finalRotate.GetBasisY() * sy; + Vector3 expectedBasisY = finalRotate.GetBasisY() * scale; EXPECT_TRUE(basisY.IsClose(expectedBasisY)); Vector3 basisZ = tm.GetBasisZ(); - Vector3 expectedBasisZ = finalRotate.GetBasisZ() * sz; + Vector3 expectedBasisZ = finalRotate.GetBasisZ() * scale; EXPECT_TRUE(basisZ.IsClose(expectedBasisZ)); } @@ -476,18 +478,15 @@ namespace UnitTest { TransformBus::Event(m_childId, &TransformBus::Events::RotateAroundLocalX, rx); } - Vector3 localScale; - TransformBus::EventResult(localScale, m_childId, &TransformBus::Events::GetLocalScale); - EXPECT_TRUE(localScale.IsClose(Vector3(1.0f, 1.0f, 1.0f))); + float localScale = FLT_MAX; + TransformBus::EventResult(localScale, m_childId, &TransformBus::Events::GetLocalUniformScale); + EXPECT_NEAR(localScale, 1.0f, AZ::Constants::Tolerance); } TEST_F(TransformComponentTransformMatrixSetGet, RotateAroundLocalX_ScaleDoesNotSkewRotation) { - float sx = 42.564f; - float sy = 12.460f; - float sz = 28.692f; - Vector3 expectedScales(sx, sy, sz); - TransformBus::Event(m_childId, &TransformBus::Events::SetLocalScale, expectedScales); + float expectedScale = 42.564f; + TransformBus::Event(m_childId, &TransformBus::Events::SetLocalUniformScale, expectedScale); float rx = 1.43f; TransformBus::Event(m_childId, &TransformBus::Events::RotateAroundLocalX, rx); @@ -513,18 +512,15 @@ namespace UnitTest { TransformBus::Event(m_childId, &TransformBus::Events::RotateAroundLocalY, ry); } - Vector3 localScale; - TransformBus::EventResult(localScale, m_childId, &TransformBus::Events::GetLocalScale); - EXPECT_TRUE(localScale.IsClose(Vector3(1.0f, 1.0f, 1.0f))); + float localScale = FLT_MAX; + TransformBus::EventResult(localScale, m_childId, &TransformBus::Events::GetLocalUniformScale); + EXPECT_NEAR(localScale, 1.0f, AZ::Constants::Tolerance); } TEST_F(TransformComponentTransformMatrixSetGet, RotateAroundLocalY_ScaleDoesNotSkewRotation) { - float sx = 42.564f; - float sy = 12.460f; - float sz = 28.692f; - Vector3 expectedScales(sx, sy, sz); - TransformBus::Event(m_childId, &TransformBus::Events::SetLocalScale, expectedScales); + float expectedScale = 42.564f; + TransformBus::Event(m_childId, &TransformBus::Events::SetLocalUniformScale, expectedScale); float ry = 1.43f; TransformBus::Event(m_childId, &TransformBus::Events::RotateAroundLocalY, ry); @@ -550,18 +546,15 @@ namespace UnitTest { TransformBus::Event(m_childId, &TransformBus::Events::RotateAroundLocalZ, rz); } - Vector3 localScale; - TransformBus::EventResult(localScale, m_childId, &TransformBus::Events::GetLocalScale); - EXPECT_TRUE(localScale.IsClose(Vector3(1.0f, 1.0f, 1.0f))); + float localScale = FLT_MAX; + TransformBus::EventResult(localScale, m_childId, &TransformBus::Events::GetLocalUniformScale); + EXPECT_NEAR(localScale, 1.0f, AZ::Constants::Tolerance); } TEST_F(TransformComponentTransformMatrixSetGet, RotateAroundLocalZ_ScaleDoesNotSkewRotation) { - float sx = 42.564f; - float sy = 12.460f; - float sz = 28.692f; - Vector3 expectedScales(sx, sy, sz); - TransformBus::Event(m_childId, &TransformBus::Events::SetLocalScale, expectedScales); + float expectedScale = 42.564f; + TransformBus::Event(m_childId, &TransformBus::Events::SetLocalUniformScale, expectedScale); float rz = 1.43f; TransformBus::Event(m_childId, &TransformBus::Events::RotateAroundLocalZ, rz); @@ -572,110 +565,50 @@ namespace UnitTest TEST_F(TransformComponentTransformMatrixSetGet, SetLocalScale_SimpleValues_Set) { - float sx = 42.564f; - float sy = 12.460f; - float sz = 28.692f; - Vector3 expectedScales(sx, sy, sz); - TransformBus::Event(m_childId, &TransformBus::Events::SetLocalScale, expectedScales); + float expectedScale = 42.564f; + TransformBus::Event(m_childId, &TransformBus::Events::SetLocalUniformScale, expectedScale); - Transform tm ; - TransformBus::EventResult(tm, m_childId, &TransformBus::Events::GetLocalTM); - Vector3 scales = tm.GetScale(); - EXPECT_TRUE(scales.IsClose(expectedScales)); - } - - TEST_F(TransformComponentTransformMatrixSetGet, SetLocalScaleX_SimpleValues_Set) - { - float sx = 64.336f; Transform tm; TransformBus::EventResult(tm, m_childId, &TransformBus::Events::GetLocalTM); - Vector3 expectedScales = tm.GetScale(); - expectedScales.SetX(sx); - - TransformBus::Event(m_childId, &TransformBus::Events::SetLocalScaleX, sx); - - TransformBus::EventResult(tm, m_childId, &TransformBus::Events::GetLocalTM); - Vector3 scales = tm.GetScale(); - EXPECT_TRUE(scales.IsClose(expectedScales)); - } - - TEST_F(TransformComponentTransformMatrixSetGet, SetLocalScaleY_SimpleValues_Set) - { - float sy = 23.754f; - Transform tm; - TransformBus::EventResult(tm, m_childId, &TransformBus::Events::GetLocalTM); - Vector3 expectedScales = tm.GetScale(); - expectedScales.SetY(sy); - - TransformBus::Event(m_childId, &TransformBus::Events::SetLocalScaleY, sy); - - TransformBus::EventResult(tm, m_childId, &TransformBus::Events::GetLocalTM); - Vector3 scales = tm.GetScale(); - EXPECT_TRUE(scales.IsClose(expectedScales)); - } - - TEST_F(TransformComponentTransformMatrixSetGet, SetLocalScaleZ_SimpleValues_Set) - { - float sz = 65.140f; - Transform tm; - TransformBus::EventResult(tm, m_childId, &TransformBus::Events::GetLocalTM); - Vector3 expectedScales = tm.GetScale(); - expectedScales.SetZ(sz); - - TransformBus::Event(m_childId, &TransformBus::Events::SetLocalScaleZ, sz); - - TransformBus::EventResult(tm, m_childId, &TransformBus::Events::GetLocalTM); - Vector3 scales = tm.GetScale(); - EXPECT_TRUE(scales.IsClose(expectedScales)); + float scale = tm.GetUniformScale(); + EXPECT_NEAR(scale, expectedScale, AZ::Constants::Tolerance); } TEST_F(TransformComponentTransformMatrixSetGet, GetLocalScale_SimpleValues_Return) { - float sx = 43.463f; - float sy = 346.22f; - float sz = 863.32f; - Vector3 expectedScales(sx, sy, sz); - Transform scaleTM = Transform::CreateScale(expectedScales); + float expectedScale = 43.463f; + Transform scaleTM = Transform::CreateUniformScale(expectedScale); TransformBus::Event(m_childId, &TransformBus::Events::SetLocalTM, scaleTM); - Vector3 scales; - TransformBus::EventResult(scales, m_childId, &TransformBus::Events::GetLocalScale); - EXPECT_TRUE(scales.IsClose(expectedScales)); + float scale; + TransformBus::EventResult(scale, m_childId, &TransformBus::Events::GetLocalUniformScale); + EXPECT_NEAR(scale, expectedScale, AZ::Constants::Tolerance); } TEST_F(TransformComponentTransformMatrixSetGet, GetWorldScale_ChildHasNoScale_ReturnScaleSameAsParent) { - float sx = 43.463f; - float sy = 346.22f; - float sz = 863.32f; - Vector3 expectedScales(sx, sy, sz); - Transform scaleTM = Transform::CreateScale(expectedScales); + float expectedScale = 43.463f; + Transform scaleTM = Transform::CreateUniformScale(expectedScale); TransformBus::Event(m_parentId, &TransformBus::Events::SetLocalTM, scaleTM); - Vector3 scales; - TransformBus::EventResult(scales, m_childId, &TransformBus::Events::GetWorldScale); - EXPECT_TRUE(scales.IsClose(expectedScales)); + float scale = FLT_MAX; + TransformBus::EventResult(scale, m_childId, &TransformBus::Events::GetWorldUniformScale); + EXPECT_NEAR(scale, expectedScale, AZ::Constants::Tolerance); } TEST_F(TransformComponentTransformMatrixSetGet, GetWorldScale_ChildHasScale_ReturnCompoundScale) { - float sx = 4.463f; - float sy = 3.22f; - float sz = 8.32f; - Vector3 parentScales(sx, sy, sz); - Transform parentScaleTM = Transform::CreateScale(parentScales); + float parentScale = 4.463f; + Transform parentScaleTM = Transform::CreateUniformScale(parentScale); TransformBus::Event(m_parentId, &TransformBus::Events::SetLocalTM, parentScaleTM); - float csx = 1.64f; - float csy = 9.35f; - float csz = 1.57f; - Vector3 childScales(csx, csy, csz); - Transform childScaleTM = Transform::CreateScale(childScales); + float childScale = 1.64f; + Transform childScaleTM = Transform::CreateUniformScale(childScale); TransformBus::Event(m_childId, &TransformBus::Events::SetLocalTM, childScaleTM); - Vector3 scales; - TransformBus::EventResult(scales, m_childId, &TransformBus::Events::GetWorldScale); - EXPECT_TRUE(scales.IsClose(parentScales * childScales)); + float scale = FLT_MAX; + TransformBus::EventResult(scale, m_childId, &TransformBus::Events::GetWorldUniformScale); + EXPECT_NEAR(scale, parentScale * childScale, AZ::Constants::Tolerance); } class TransformComponentHierarchy diff --git a/Code/Sandbox/Editor/Objects/SelectionGroup.cpp b/Code/Sandbox/Editor/Objects/SelectionGroup.cpp index a2c88c7302..aacf531203 100644 --- a/Code/Sandbox/Editor/Objects/SelectionGroup.cpp +++ b/Code/Sandbox/Editor/Objects/SelectionGroup.cpp @@ -482,28 +482,6 @@ void CSelectionGroup::StartScaling() } -void CSelectionGroup::FinishScaling(const Vec3& scale, [[maybe_unused]] int referenceCoordSys) -{ - if (fabs(scale.x - scale.y) < 0.001f && - fabs(scale.y - scale.z) < 0.001f && - fabs(scale.z - scale.x) < 0.001f) - { - return; - } - - for (int i = 0; i < GetFilteredCount(); ++i) - { - CBaseObject* obj = GetFilteredObject(i); - Vec3 OriginalScale; - if (obj->GetUntransformedScale(OriginalScale)) - { - obj->TransformScale(scale); - obj->SetScale(OriginalScale); - } - } -} - - ////////////////////////////////////////////////////////////////////////// void CSelectionGroup::Align() { diff --git a/Code/Sandbox/Editor/Objects/SelectionGroup.h b/Code/Sandbox/Editor/Objects/SelectionGroup.h index 277ff2a492..9f672f28b2 100644 --- a/Code/Sandbox/Editor/Objects/SelectionGroup.h +++ b/Code/Sandbox/Editor/Objects/SelectionGroup.h @@ -103,7 +103,6 @@ public: void StartScaling(); void Scale(const Vec3& scale, int referenceCoordSys); void SetScale(const Vec3& scale, int referenceCoordSys); - void FinishScaling(const Vec3& scale, int referenceCoordSys); //! Align objects in selection to surface normal void Align(); //! Very special method to move contents of a voxel. diff --git a/Code/Tools/SceneAPI/SceneCore/Containers/Utilities/SceneUtilities.cpp b/Code/Tools/SceneAPI/SceneCore/Containers/Utilities/SceneUtilities.cpp index f5bb9d28a6..ac27ed54eb 100644 --- a/Code/Tools/SceneAPI/SceneCore/Containers/Utilities/SceneUtilities.cpp +++ b/Code/Tools/SceneAPI/SceneCore/Containers/Utilities/SceneUtilities.cpp @@ -79,7 +79,7 @@ namespace AZ if (coordinateSystemRule->GetScale() != 1.0f) { float scale = coordinateSystemRule->GetScale(); - matrix.MultiplyByScale(Vector3(scale, scale, scale)); + matrix.MultiplyByScale(Vector3(scale)); } if (!coordinateSystemRule->GetOriginNodeName().empty()) { diff --git a/Gems/Atom/Tools/MaterialEditor/Code/Source/Viewport/MaterialViewportRenderer.cpp b/Gems/Atom/Tools/MaterialEditor/Code/Source/Viewport/MaterialViewportRenderer.cpp index c7265e0039..b08f5b1165 100644 --- a/Gems/Atom/Tools/MaterialEditor/Code/Source/Viewport/MaterialViewportRenderer.cpp +++ b/Gems/Atom/Tools/MaterialEditor/Code/Source/Viewport/MaterialViewportRenderer.cpp @@ -16,6 +16,7 @@ #include #include +#include #include #include @@ -182,9 +183,10 @@ namespace MaterialEditor m_shadowCatcherEntity->CreateComponent(AZ::Render::MeshComponentTypeId); m_shadowCatcherEntity->CreateComponent(AZ::Render::MaterialComponentTypeId); m_shadowCatcherEntity->CreateComponent(azrtti_typeid()); + m_shadowCatcherEntity->CreateComponent(azrtti_typeid()); m_shadowCatcherEntity->Activate(); - AZ::TransformBus::Event(m_shadowCatcherEntity->GetId(), &AZ::TransformBus::Events::SetLocalScale, AZ::Vector3{ 100, 100, 1.0 }); + AZ::NonUniformScaleRequestBus::Event(m_shadowCatcherEntity->GetId(), &AZ::NonUniformScaleRequests::SetScale, AZ::Vector3{ 100, 100, 1.0 }); AZ::Data::AssetId shadowCatcherModelAssetId = RPI::AssetUtils::GetAssetIdForProductPath("materialeditor/viewportmodels/plane_1x1.azmodel", RPI::AssetUtils::TraceLevel::Error); AZ::Render::MeshComponentRequestBus::Event(m_shadowCatcherEntity->GetId(), diff --git a/Gems/AtomLyIntegration/CommonFeatures/Code/Source/CoreLights/PolygonLightDelegate.cpp b/Gems/AtomLyIntegration/CommonFeatures/Code/Source/CoreLights/PolygonLightDelegate.cpp index c2bcc566e0..e01559041c 100644 --- a/Gems/AtomLyIntegration/CommonFeatures/Code/Source/CoreLights/PolygonLightDelegate.cpp +++ b/Gems/AtomLyIntegration/CommonFeatures/Code/Source/CoreLights/PolygonLightDelegate.cpp @@ -50,7 +50,7 @@ namespace AZ AZStd::vector vertices = m_shapeBus->GetPolygonPrism()->m_vertexContainer.GetVertices(); Transform transform = GetTransform(); - transform.SetScale(Vector3(transform.GetScale().GetMaxElement())); // Poly Prism only supports uniform scale, so use max element. + transform.SetUniformScale(transform.GetUniformScale()); // Poly Prism only supports uniform scale. AZStd::vector transformedVertices; transformedVertices.reserve(vertices.size()); diff --git a/Gems/Blast/Code/Tests/Mocks/BlastMocks.h b/Gems/Blast/Code/Tests/Mocks/BlastMocks.h index 1ae87e2282..bd03a442d9 100644 --- a/Gems/Blast/Code/Tests/Mocks/BlastMocks.h +++ b/Gems/Blast/Code/Tests/Mocks/BlastMocks.h @@ -666,20 +666,12 @@ namespace Blast MOCK_METHOD1(RotateAroundLocalZ, void(float)); MOCK_METHOD0(GetLocalRotation, AZ::Vector3()); MOCK_METHOD0(GetLocalRotationQuaternion, AZ::Quaternion()); - MOCK_METHOD1(SetScale, void(const AZ::Vector3&)); - MOCK_METHOD1(SetScaleX, void(float)); - MOCK_METHOD1(SetScaleY, void(float)); - MOCK_METHOD1(SetScaleZ, void(float)); - MOCK_METHOD0(GetScale, AZ::Vector3()); - MOCK_METHOD0(GetScaleX, float()); - MOCK_METHOD0(GetScaleY, float()); - MOCK_METHOD0(GetScaleZ, float()); MOCK_METHOD1(SetLocalScale, void(const AZ::Vector3&)); - MOCK_METHOD1(SetLocalScaleX, void(float)); - MOCK_METHOD1(SetLocalScaleY, void(float)); - MOCK_METHOD1(SetLocalScaleZ, void(float)); MOCK_METHOD0(GetLocalScale, AZ::Vector3()); MOCK_METHOD0(GetWorldScale, AZ::Vector3()); + MOCK_METHOD1(SetLocalUniformScale, void(float)); + MOCK_METHOD0(GetLocalUniformScale, float()); + MOCK_METHOD0(GetWorldUniformScale, float()); MOCK_METHOD0(GetParentId, AZ::EntityId()); MOCK_METHOD0(GetParent, TransformInterface*()); MOCK_METHOD1(SetParent, void(AZ::EntityId)); diff --git a/Gems/EMotionFX/Code/EMotionFX/Rendering/Common/RenderUtil.cpp b/Gems/EMotionFX/Code/EMotionFX/Rendering/Common/RenderUtil.cpp index 0aef3f9d4f..3a23241385 100644 --- a/Gems/EMotionFX/Code/EMotionFX/Rendering/Common/RenderUtil.cpp +++ b/Gems/EMotionFX/Code/EMotionFX/Rendering/Common/RenderUtil.cpp @@ -1157,7 +1157,7 @@ namespace MCommon void RenderUtil::RenderSphere(const AZ::Vector3& position, float radius, const MCore::RGBAColor& color) { // setup the world space matrix of the sphere - AZ::Transform sphereTransform = AZ::Transform::CreateScale(AZ::Vector3(radius, radius, radius)); + AZ::Transform sphereTransform = AZ::Transform::CreateUniformScale(radius); sphereTransform.SetTranslation(position); // render the sphere diff --git a/Gems/GradientSignal/Code/Include/GradientSignal/Util.h b/Gems/GradientSignal/Code/Include/GradientSignal/Util.h index 4e15bdc293..1a8bb00eba 100644 --- a/Gems/GradientSignal/Code/Include/GradientSignal/Util.h +++ b/Gems/GradientSignal/Code/Include/GradientSignal/Util.h @@ -14,6 +14,7 @@ #include #include #include +#include #include #include @@ -64,15 +65,15 @@ namespace GradientSignal AZ::LerpInverse(bounds.GetMin().GetZ(), bounds.GetMax().GetZ(), point.GetZ())); } - inline void GetObbParamsFromShape(const AZ::EntityId& entity, AZ::Aabb& bounds, AZ::Transform& worldToBoundsTransform) + inline void GetObbParamsFromShape(const AZ::EntityId& entity, AZ::Aabb& bounds, AZ::Matrix3x4& worldToBoundsTransform) { //get bound and transform data for associated shape bounds = AZ::Aabb::CreateNull(); - worldToBoundsTransform = AZ::Transform::CreateIdentity(); + AZ::Transform transform = AZ::Transform::CreateIdentity(); if (entity.IsValid()) { - LmbrCentral::ShapeComponentRequestsBus::Event(entity, &LmbrCentral::ShapeComponentRequestsBus::Events::GetTransformAndLocalBounds, worldToBoundsTransform, bounds); - worldToBoundsTransform.Invert(); + LmbrCentral::ShapeComponentRequestsBus::Event(entity, &LmbrCentral::ShapeComponentRequestsBus::Events::GetTransformAndLocalBounds, transform, bounds); + worldToBoundsTransform = AZ::Matrix3x4::CreateFromTransform(transform.GetInverse()); } } diff --git a/Gems/GradientSignal/Code/Source/Components/GradientTransformComponent.cpp b/Gems/GradientSignal/Code/Source/Components/GradientTransformComponent.cpp index f99a8a8dfb..336f428582 100644 --- a/Gems/GradientSignal/Code/Source/Components/GradientTransformComponent.cpp +++ b/Gems/GradientSignal/Code/Source/Components/GradientTransformComponent.cpp @@ -334,7 +334,7 @@ namespace GradientSignal AZStd::lock_guard lock(m_cacheMutex); //transforming coordinate into "local" relative space of shape bounds - outUVW = m_shapeTransformInverse.TransformPoint(inPosition); + outUVW = m_shapeTransformInverse * inPosition; if (!m_configuration.m_advancedMode || !m_configuration.m_is3d) { @@ -388,7 +388,7 @@ namespace GradientSignal void GradientTransformComponent::GetGradientEncompassingBounds(AZ::Aabb& bounds) const { bounds = m_shapeBounds; - bounds.ApplyTransform(m_shapeTransformInverse.GetInverse()); + bounds.ApplyMatrix3x4(m_shapeTransformInverse.GetInverseFull()); } void GradientTransformComponent::OnCompositionChanged() @@ -501,10 +501,11 @@ namespace GradientSignal m_shapeBounds = AZ::Aabb::CreateFromMinMax(-m_configuration.m_bounds * 0.5f, m_configuration.m_bounds * 0.5f); //rebuild transform from parameters - AZ::Quaternion rotation; - rotation.SetFromEulerDegrees(m_configuration.m_rotate); - const AZ::Transform shapeTransformFinal(m_configuration.m_translate, rotation, m_configuration.m_scale); - m_shapeTransformInverse = shapeTransformFinal.GetInverse(); + AZ::Matrix3x4 shapeTransformFinal; + shapeTransformFinal.SetFromEulerDegrees(m_configuration.m_rotate); + shapeTransformFinal.SetTranslation(m_configuration.m_translate); + shapeTransformFinal.MultiplyByScale(m_configuration.m_scale); + m_shapeTransformInverse = shapeTransformFinal.GetInverseFull(); } AZ::EntityId GradientTransformComponent::GetShapeEntityId() const diff --git a/Gems/GradientSignal/Code/Source/Components/GradientTransformComponent.h b/Gems/GradientSignal/Code/Source/Components/GradientTransformComponent.h index 8b0bfad672..5955da95c7 100644 --- a/Gems/GradientSignal/Code/Source/Components/GradientTransformComponent.h +++ b/Gems/GradientSignal/Code/Source/Components/GradientTransformComponent.h @@ -15,6 +15,7 @@ #include #include #include +#include #include #include #include @@ -172,7 +173,7 @@ namespace GradientSignal mutable AZStd::recursive_mutex m_cacheMutex; GradientTransformConfig m_configuration; AZ::Aabb m_shapeBounds = AZ::Aabb::CreateNull(); - AZ::Transform m_shapeTransformInverse = AZ::Transform::CreateIdentity(); + AZ::Matrix3x4 m_shapeTransformInverse = AZ::Matrix3x4::CreateIdentity(); LmbrCentral::DependencyMonitor m_dependencyMonitor; AZStd::atomic_bool m_dirty{ false }; }; diff --git a/Gems/LmbrCentral/Code/Source/Scripting/EditorLookAtComponent.cpp b/Gems/LmbrCentral/Code/Source/Scripting/EditorLookAtComponent.cpp index 107b94d119..e16260af4d 100644 --- a/Gems/LmbrCentral/Code/Source/Scripting/EditorLookAtComponent.cpp +++ b/Gems/LmbrCentral/Code/Source/Scripting/EditorLookAtComponent.cpp @@ -169,22 +169,24 @@ namespace LmbrCentral { AZ::TransformNotificationBus::MultiHandler::BusDisconnect(GetEntityId()); { - AZ::Transform currentTM = AZ::Transform::CreateIdentity(); - EBUS_EVENT_ID_RESULT(currentTM, GetEntityId(), AZ::TransformBus, GetWorldTM); - AZ::Vector3 currentScale = currentTM.ExtractScale(); + AZ::Transform sourceTM = AZ::Transform::CreateIdentity(); + AZ::TransformBus::EventResult(sourceTM, GetEntityId(), &AZ::TransformBus::Events::GetWorldTM); AZ::Transform targetTM = AZ::Transform::CreateIdentity(); - EBUS_EVENT_ID_RESULT(targetTM, m_targetId, AZ::TransformBus, GetWorldTM); + AZ::TransformBus::EventResult(targetTM, m_targetId, &AZ::TransformBus::Events::GetWorldTM); AZ::Transform lookAtTransform = AZ::Transform::CreateLookAt( - currentTM.GetTranslation(), + sourceTM.GetTranslation(), targetTM.GetTranslation(), m_forwardAxis ); - lookAtTransform.MultiplyByScale(currentScale); + // update the rotation and translation for sourceTM based on lookAtTransform, but leave scale unchanged + sourceTM.SetRotation(lookAtTransform.GetRotation()); + sourceTM.SetTranslation(lookAtTransform.GetTranslation()); EBUS_EVENT_ID(GetEntityId(), AZ::TransformBus, SetWorldTM, lookAtTransform); + AZ::TransformBus::Event(GetEntityId(), &AZ::TransformBus::Events::SetWorldTM, sourceTM); } AZ::TransformNotificationBus::MultiHandler::BusConnect(GetEntityId()); } diff --git a/Gems/LmbrCentral/Code/Source/Shape/BoxShape.cpp b/Gems/LmbrCentral/Code/Source/Shape/BoxShape.cpp index 2830f514fe..a2ee4d986f 100644 --- a/Gems/LmbrCentral/Code/Source/Shape/BoxShape.cpp +++ b/Gems/LmbrCentral/Code/Source/Shape/BoxShape.cpp @@ -251,7 +251,7 @@ namespace LmbrCentral const AZ::Transform& currentTransform, const BoxShapeConfig& configuration, const AZ::Vector3& currentNonUniformScale) { AZ::Transform worldFromLocalNormalized = currentTransform; - const float entityScale = worldFromLocalNormalized.ExtractScale().GetMaxElement(); + const float entityScale = worldFromLocalNormalized.ExtractUniformScale(); m_currentPosition = worldFromLocalNormalized.GetTranslation(); m_scaledDimensions = configuration.m_dimensions * currentNonUniformScale * entityScale; diff --git a/Gems/LmbrCentral/Code/Source/Shape/PolygonPrismShape.cpp b/Gems/LmbrCentral/Code/Source/Shape/PolygonPrismShape.cpp index 3ea8f2a3d0..4244199b85 100644 --- a/Gems/LmbrCentral/Code/Source/Shape/PolygonPrismShape.cpp +++ b/Gems/LmbrCentral/Code/Source/Shape/PolygonPrismShape.cpp @@ -434,8 +434,7 @@ namespace LmbrCentral const AZ::Vector3& nonUniformScale = polygonPrism.GetNonUniformScale(); AZ::Transform worldFromLocalUniformScale = worldFromLocal; - const float entityScale = worldFromLocalUniformScale.ExtractScale().GetMaxElement(); - worldFromLocalUniformScale *= AZ::Transform::CreateScale(AZ::Vector3(entityScale)); + worldFromLocalUniformScale.SetUniformScale(worldFromLocalUniformScale.GetUniformScale()); AZ::Aabb aabb = AZ::Aabb::CreateNull(); // check base of prism @@ -465,8 +464,7 @@ namespace LmbrCentral const size_t vertexCount = vertices.size(); AZ::Transform worldFromLocalWithUniformScale = worldFromLocal; - const float transformScale = worldFromLocalWithUniformScale.ExtractScale().GetMaxElement(); - worldFromLocalWithUniformScale *= AZ::Transform::CreateScale(AZ::Vector3(transformScale)); + worldFromLocalWithUniformScale.SetUniformScale(worldFromLocalWithUniformScale.GetUniformScale()); // transform point to local space // it's fine to invert the transform including scale here, because it won't affect whether the point is inside the prism @@ -530,7 +528,7 @@ namespace LmbrCentral // but inverting any scale in the transform would mess up the distance, so extract that first and apply scale separately to the // prism AZ::Transform worldFromLocalNoScale = worldFromLocal; - const float transformScale = worldFromLocalNoScale.ExtractScale().GetMaxElement(); + const float transformScale = worldFromLocalNoScale.ExtractUniformScale(); const AZ::Vector3 combinedScale = transformScale * nonUniformScale; const float scaledHeight = height * combinedScale.GetZ(); @@ -606,9 +604,9 @@ namespace LmbrCentral } // transform ray into local space - AZ::Transform worldFromLocalNomalized = worldFromLocal; - const float entityScale = worldFromLocalNomalized.ExtractScale().GetMaxElement(); - const AZ::Transform localFromWorldNormalized = worldFromLocalNomalized.GetInverse(); + AZ::Transform worldFromLocalNormalized = worldFromLocal; + const float entityScale = worldFromLocalNormalized.ExtractUniformScale(); + const AZ::Transform localFromWorldNormalized = worldFromLocalNormalized.GetInverse(); const float rayLength = 1000.0f; const AZ::Vector3 localSrc = localFromWorldNormalized.TransformPoint(src); const AZ::Vector3 localDir = localFromWorldNormalized.TransformVector(dir); diff --git a/Gems/LmbrCentral/Code/Source/Shape/ShapeDisplay.h b/Gems/LmbrCentral/Code/Source/Shape/ShapeDisplay.h index fb3164960e..5b5cc5fb4d 100644 --- a/Gems/LmbrCentral/Code/Source/Shape/ShapeDisplay.h +++ b/Gems/LmbrCentral/Code/Source/Shape/ShapeDisplay.h @@ -44,8 +44,7 @@ namespace LmbrCentral // only uniform scale is supported in physics so the debug visuals reflect this fact AZ::Transform worldFromLocalWithUniformScale = worldFromLocal; - const AZ::Vector3 scale = worldFromLocalWithUniformScale.ExtractScale(); - worldFromLocalWithUniformScale.MultiplyByScale(AZ::Vector3(scale.GetMaxElement())); + worldFromLocalWithUniformScale.SetUniformScale(worldFromLocalWithUniformScale.GetUniformScale()); debugDisplay.PushMatrix(worldFromLocalWithUniformScale); diff --git a/Gems/LmbrCentral/Code/Source/Shape/TubeShape.cpp b/Gems/LmbrCentral/Code/Source/Shape/TubeShape.cpp index 6ca2e55de8..0db2660e01 100644 --- a/Gems/LmbrCentral/Code/Source/Shape/TubeShape.cpp +++ b/Gems/LmbrCentral/Code/Source/Shape/TubeShape.cpp @@ -187,7 +187,7 @@ namespace LmbrCentral static AZ::Aabb CalculateTubeBounds(const TubeShape& tubeShape, const AZ::Transform& transform) { - const auto maxScale = transform.GetScale().GetMaxElement(); + const auto maxScale = transform.GetUniformScale(); const auto scaledRadiusFn = [&tubeShape, maxScale](const AZ::SplineAddress& splineAddress) { @@ -217,8 +217,7 @@ namespace LmbrCentral } AZ::Transform worldFromLocalUniformScale = m_currentTransform; - const float maxScale = worldFromLocalUniformScale.ExtractScale().GetMaxElement(); - worldFromLocalUniformScale *= AZ::Transform::CreateScale(AZ::Vector3(maxScale)); + worldFromLocalUniformScale.SetUniformScale(worldFromLocalUniformScale.GetUniformScale()); return CalculateTubeBounds(*this, worldFromLocalUniformScale); } @@ -237,45 +236,43 @@ namespace LmbrCentral } AZ::Transform worldFromLocalNormalized = m_currentTransform; - const AZ::Vector3 scale = AZ::Vector3(worldFromLocalNormalized.ExtractScale().GetMaxElement()); + const float scale = worldFromLocalNormalized.ExtractUniformScale(); const AZ::Transform localFromWorldNormalized = worldFromLocalNormalized.GetInverse(); - const AZ::Vector3 localPoint = localFromWorldNormalized.TransformPoint(point) * scale.GetReciprocal(); + const AZ::Vector3 localPoint = localFromWorldNormalized.TransformPoint(point) / scale; const auto address = m_spline->GetNearestAddressPosition(localPoint).m_splineAddress; const float radiusSq = powf(m_radius, 2.0f); const float variableRadiusSq = powf(m_variableRadius.GetElementInterpolated(address, Lerpf), 2.0f); - return (m_spline->GetPosition(address) - localPoint).GetLengthSq() < (radiusSq + variableRadiusSq) * - scale.GetMaxElement(); + return (m_spline->GetPosition(address) - localPoint).GetLengthSq() < (radiusSq + variableRadiusSq) * scale; } float TubeShape::DistanceSquaredFromPoint(const AZ::Vector3& point) { AZ::Transform worldFromLocalNormalized = m_currentTransform; - const AZ::Vector3 maxScale = AZ::Vector3(worldFromLocalNormalized.ExtractScale().GetMaxElement()); + const float uniformScale = worldFromLocalNormalized.ExtractUniformScale(); const AZ::Transform localFromWorldNormalized = worldFromLocalNormalized.GetInverse(); - const AZ::Vector3 localPoint = localFromWorldNormalized.TransformPoint(point) * maxScale.GetReciprocal(); + const AZ::Vector3 localPoint = localFromWorldNormalized.TransformPoint(point) / uniformScale; const auto splineQueryResult = m_spline->GetNearestAddressPosition(localPoint); const float variableRadius = m_variableRadius.GetElementInterpolated(splineQueryResult.m_splineAddress, Lerpf); - return powf((sqrtf(splineQueryResult.m_distanceSq) - (m_radius + variableRadius)) * maxScale.GetMaxElement(), 2.0f); + return powf((sqrtf(splineQueryResult.m_distanceSq) - (m_radius + variableRadius)) * uniformScale, 2.0f); } bool TubeShape::IntersectRay(const AZ::Vector3& src, const AZ::Vector3& dir, float& distance) { AZ::Transform transformUniformScale = m_currentTransform; - const float maxScale = transformUniformScale.ExtractScale().GetMaxElement(); - transformUniformScale *= AZ::Transform::CreateScale(AZ::Vector3(maxScale)); + transformUniformScale.SetUniformScale(transformUniformScale.GetUniformScale()); const auto splineQueryResult = IntersectSpline(transformUniformScale, src, dir, *m_spline); const float variableRadius = m_variableRadius.GetElementInterpolated( splineQueryResult.m_splineAddress, Lerpf); const float totalRadius = m_radius + variableRadius; - distance = (splineQueryResult.m_rayDistance - totalRadius) * m_currentTransform.GetScale().GetMaxElement(); + distance = (splineQueryResult.m_rayDistance - totalRadius) * m_currentTransform.GetUniformScale(); return static_cast(sqrtf(splineQueryResult.m_distanceSq)) < totalRadius; } diff --git a/Gems/LmbrCentral/Code/Tests/BoxShapeTest.cpp b/Gems/LmbrCentral/Code/Tests/BoxShapeTest.cpp index fd1e4ae4f1..5df486d9a2 100644 --- a/Gems/LmbrCentral/Code/Tests/BoxShapeTest.cpp +++ b/Gems/LmbrCentral/Code/Tests/BoxShapeTest.cpp @@ -262,7 +262,7 @@ namespace UnitTest AZ::Transform::CreateFromQuaternionAndTranslation( AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisY(), AZ::Constants::QuarterPi), AZ::Vector3(0.0f, 0.0f, 5.0f)) * - AZ::Transform::CreateScale(AZ::Vector3(3.0f)), + AZ::Transform::CreateUniformScale(3.0f), AZ::Vector3(2.0f, 4.0f, 1.0f), entity); bool rayHit = false; @@ -295,7 +295,7 @@ namespace UnitTest { AZ::Entity entity; AZ::Transform transform = AZ::Transform::CreateTranslation(AZ::Vector3(2.0f, -5.0f, 3.0f)); - transform.MultiplyByScale(AZ::Vector3(0.5f)); + transform.MultiplyByUniformScale(0.5f); const AZ::Vector3 dimensions(2.2f, 1.8f, 0.4f); const AZ::Vector3 nonUniformScale(0.2f, 2.6f, 1.2f); CreateBoxWithNonUniformScale(transform, dimensions, nonUniformScale, entity); @@ -340,7 +340,7 @@ namespace UnitTest AZ::Entity entity; AZ::Transform transform = AZ::Transform::CreateFromQuaternionAndTranslation( AZ::Quaternion(0.50f, 0.10f, 0.02f, 0.86f), AZ::Vector3(4.0f, 1.0f, -2.0f)); - transform.MultiplyByScale(AZ::Vector3(1.5f)); + transform.MultiplyByUniformScale(1.5f); const AZ::Vector3 dimensions(1.2f, 0.7f, 2.1f); const AZ::Vector3 nonUniformScale(0.8f, 0.6f, 0.7f); CreateBoxWithNonUniformScale(transform, dimensions, nonUniformScale, entity); @@ -433,7 +433,7 @@ namespace UnitTest AZ::Transform::CreateFromQuaternionAndTranslation( AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisY(), AZ::Constants::QuarterPi), AZ::Vector3::CreateZero()) * - AZ::Transform::CreateScale(AZ::Vector3(3.0f)), + AZ::Transform::CreateUniformScale(3.0f), AZ::Vector3(2.0f, 4.0f, 1.0f), entity); AZ::Aabb aabb; @@ -483,7 +483,7 @@ namespace UnitTest AZ::Transform transformIn = AZ::Transform::CreateFromQuaternionAndTranslation( AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisX(), AZ::Constants::QuarterPi) * AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisY(), AZ::Constants::QuarterPi), AZ::Vector3(9.0f, 11.0f, 13.0f)); - transformIn.MultiplyByScale(AZ::Vector3(3.0f)); + transformIn.MultiplyByUniformScale(3.0f); CreateBox(transformIn, AZ::Vector3(1.5f, 3.5f, 5.5f), entity); AZ::Transform transformOut; @@ -500,7 +500,7 @@ namespace UnitTest AZ::Entity entity; AZ::Transform transformIn = AZ::Transform::CreateFromQuaternionAndTranslation( AZ::Quaternion(0.62f, 0.62f, 0.14f, 0.46f), AZ::Vector3(0.8f, -1.2f, 2.7f)); - transformIn.MultiplyByScale(AZ::Vector3(2.0f)); + transformIn.MultiplyByUniformScale(2.0f); const AZ::Vector3 nonUniformScale(1.5f, 2.0f, 0.4f); const AZ::Vector3 boxDimensions(2.0f, 1.7f, 0.5f); CreateBoxWithNonUniformScale(transformIn, nonUniformScale, boxDimensions, entity); @@ -531,7 +531,7 @@ namespace UnitTest AZ::Transform::CreateFromQuaternionAndTranslation( AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisZ(), AZ::Constants::QuarterPi), AZ::Vector3(23.0f, 12.0f, 40.0f)) * - AZ::Transform::CreateScale(AZ::Vector3(3.0f)), + AZ::Transform::CreateUniformScale(3.0f), AZ::Vector3(2.0f, 6.0f, 3.5f), entity); // test some pairs of nearby points which should be just either side of the surface of the box @@ -551,7 +551,7 @@ namespace UnitTest AZ::Transform::CreateTranslation(AZ::Vector3(23.0f, 12.0f, 40.0f)) * AZ::Transform::CreateRotationX(-AZ::Constants::QuarterPi) * AZ::Transform::CreateRotationZ(AZ::Constants::QuarterPi) * - AZ::Transform::CreateScale(AZ::Vector3(2.0f)), + AZ::Transform::CreateUniformScale(2.0f), AZ::Vector3(4.0f, 7.0f, 3.5f), entity); // test some pairs of nearby points which should be just either side of the surface of the box @@ -588,14 +588,14 @@ namespace UnitTest CreateBox( AZ::Transform::CreateTranslation(AZ::Vector3(10.0f, 37.0f, 32.0f)) * AZ::Transform::CreateRotationZ(AZ::Constants::QuarterPi) * - AZ::Transform::CreateScale(AZ::Vector3(3.0f, 1.0f, 1.0f)), - AZ::Vector3(4.0f, 2.0f, 10.0f), entity); + AZ::Transform::CreateUniformScale(2.0f), + AZ::Vector3(6.0f, 1.0f, 5.0f), entity); float distance; LmbrCentral::ShapeComponentRequestsBus::EventResult( - distance, entity.GetId(), &LmbrCentral::ShapeComponentRequests::DistanceFromPoint, AZ::Vector3(3.6356f, 30.636f, 40.0f)); + distance, entity.GetId(), &LmbrCentral::ShapeComponentRequests::DistanceFromPoint, AZ::Vector3(4.0f, 33.5f, 38.0f)); - EXPECT_NEAR(distance, 3.0f, 1e-2f); + EXPECT_NEAR(distance, 1.45f, 1e-2f); } // distance scaled @@ -606,14 +606,14 @@ namespace UnitTest AZ::Transform::CreateTranslation(AZ::Vector3(10.0f, 37.0f, 32.0f)) * AZ::Transform::CreateRotationX(AZ::Constants::HalfPi) * AZ::Transform::CreateRotationY(AZ::Constants::HalfPi) * - AZ::Transform::CreateScale(AZ::Vector3(3.0f, 1.0f, 1.0f)), - AZ::Vector3(4.0f, 2.0f, 10.0f), entity); + AZ::Transform::CreateUniformScale(0.5f), + AZ::Vector3(24.0f, 4.0f, 20.0f), entity); float distance; LmbrCentral::ShapeComponentRequestsBus::EventResult( distance, entity.GetId(), &LmbrCentral::ShapeComponentRequests::DistanceFromPoint, AZ::Vector3(10.0f, 37.0f, 48.0f)); - EXPECT_NEAR(distance, 13.0f, 1e-2f); + EXPECT_NEAR(distance, 15.0f, 1e-2f); } TEST_F(BoxShapeTest, DistanceFromPointNonUniformScale) @@ -621,7 +621,7 @@ namespace UnitTest AZ::Entity entity; AZ::Transform transform = AZ::Transform::CreateFromQuaternionAndTranslation( AZ::Quaternion::CreateRotationY(AZ::DegToRad(30.0f)), AZ::Vector3(3.0f, 4.0f, 5.0f)); - transform.MultiplyByScale(AZ::Vector3(2.0f)); + transform.MultiplyByUniformScale(2.0f); const AZ::Vector3 dimensions(2.0f, 3.0f, 1.5f); const AZ::Vector3 nonUniformScale(1.4f, 2.2f, 0.8f); CreateBoxWithNonUniformScale(transform, nonUniformScale, dimensions, entity); @@ -638,7 +638,7 @@ namespace UnitTest AZ::Entity entity; AZ::Transform transform = AZ::Transform::CreateFromQuaternionAndTranslation( AZ::Quaternion(0.70f, 0.10f, 0.34f, 0.62f), AZ::Vector3(3.0f, -1.0f, 2.0f)); - transform.MultiplyByScale(AZ::Vector3(2.0f)); + transform.MultiplyByUniformScale(2.0f); const AZ::Vector3 dimensions(1.2f, 0.8f, 1.7f); const AZ::Vector3 nonUniformScale(2.4f, 1.3f, 1.8f); CreateBoxWithNonUniformScale(transform, nonUniformScale, dimensions, entity); diff --git a/Gems/LmbrCentral/Code/Tests/CapsuleShapeTest.cpp b/Gems/LmbrCentral/Code/Tests/CapsuleShapeTest.cpp index 9b57cd46c7..3274585e63 100644 --- a/Gems/LmbrCentral/Code/Tests/CapsuleShapeTest.cpp +++ b/Gems/LmbrCentral/Code/Tests/CapsuleShapeTest.cpp @@ -144,7 +144,7 @@ namespace UnitTest CreateCapsule( AZ::Transform::CreateTranslation(AZ::Vector3(-4.0f, -12.0f, -3.0f)) * AZ::Transform::CreateRotationX(AZ::Constants::HalfPi) * - AZ::Transform::CreateScale(AZ::Vector3(6.0f)), + AZ::Transform::CreateUniformScale(6.0f), 0.25f, 1.5f, entity); bool rayHit = false; @@ -208,7 +208,7 @@ namespace UnitTest TEST_F(CapsuleShapeTest, GetAabb3) { AZ::Entity entity; - CreateCapsule(AZ::Transform::CreateScale(AZ::Vector3(3.5f)), 2.0f, 4.0f, entity); + CreateCapsule(AZ::Transform::CreateUniformScale(3.5f), 2.0f, 4.0f, entity); AZ::Aabb aabb; LmbrCentral::ShapeComponentRequestsBus::EventResult( @@ -224,7 +224,7 @@ namespace UnitTest AZ::Entity entity; CreateCapsule( AZ::Transform::CreateTranslation(AZ::Vector3(5.0f, 20.0f, 0.0f)) * - AZ::Transform::CreateScale(AZ::Vector3(2.5f)), 1.0f, 5.0f, entity); + AZ::Transform::CreateUniformScale(2.5f), 1.0f, 5.0f, entity); AZ::Aabb aabb; LmbrCentral::ShapeComponentRequestsBus::EventResult( @@ -255,7 +255,7 @@ namespace UnitTest AZ::Transform transformIn = AZ::Transform::CreateFromQuaternionAndTranslation( AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisX(), AZ::Constants::HalfPi) * AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisY(), AZ::Constants::QuarterPi), AZ::Vector3(-10.0f, -10.0f, 0.0f)); - transformIn.MultiplyByScale(AZ::Vector3(3.0f)); + transformIn.MultiplyByUniformScale(3.0f); CreateCapsule(transformIn, 5.0f, 2.0f, entity); AZ::Transform transformOut; @@ -273,7 +273,7 @@ namespace UnitTest AZ::Transform transformIn = AZ::Transform::CreateFromQuaternionAndTranslation( AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisX(), AZ::Constants::HalfPi) * AZ::Quaternion::CreateFromAxisAngle(AZ::Vector3::CreateAxisY(), AZ::Constants::QuarterPi), AZ::Vector3(-10.0f, -10.0f, 0.0f)); - transformIn.MultiplyByScale(AZ::Vector3(3.0f)); + transformIn.MultiplyByUniformScale(3.0f); CreateCapsule(transformIn, 2.0f, 5.0f, entity); AZ::Transform transformOut; @@ -291,7 +291,7 @@ namespace UnitTest AZ::Entity entity; CreateCapsule( AZ::Transform::CreateTranslation(AZ::Vector3(27.0f, 28.0f, 38.0f)) * - AZ::Transform::CreateScale(AZ::Vector3(2.5f, 1.0f, 1.0f)), // test max scale + AZ::Transform::CreateUniformScale(2.5f), 0.5f, 2.0f, entity); bool inside; @@ -309,7 +309,7 @@ namespace UnitTest AZ::Transform::CreateTranslation(AZ::Vector3(27.0f, 28.0f, 38.0f)) * AZ::Transform::CreateRotationX(AZ::Constants::HalfPi) * AZ::Transform::CreateRotationY(AZ::Constants::QuarterPi) * - AZ::Transform::CreateScale(AZ::Vector3(0.5f)), + AZ::Transform::CreateUniformScale(0.5f), 0.5f, 2.0f, entity); bool inside; @@ -327,7 +327,7 @@ namespace UnitTest AZ::Transform::CreateTranslation(AZ::Vector3(27.0f, 28.0f, 38.0f)) * AZ::Transform::CreateRotationX(AZ::Constants::HalfPi) * AZ::Transform::CreateRotationY(AZ::Constants::QuarterPi) * - AZ::Transform::CreateScale(AZ::Vector3(2.0f)), + AZ::Transform::CreateUniformScale(2.0f), 0.5f, 4.0f, entity); float distance; @@ -345,7 +345,7 @@ namespace UnitTest AZ::Transform::CreateTranslation(AZ::Vector3(27.0f, 28.0f, 38.0f)) * AZ::Transform::CreateRotationX(AZ::Constants::HalfPi) * AZ::Transform::CreateRotationY(AZ::Constants::QuarterPi) * - AZ::Transform::CreateScale(AZ::Vector3(2.0f)), + AZ::Transform::CreateUniformScale(2.0f), 0.5f, 4.0f, entity); float distance; diff --git a/Gems/LmbrCentral/Code/Tests/CylinderShapeTest.cpp b/Gems/LmbrCentral/Code/Tests/CylinderShapeTest.cpp index 893ed3fcac..115abcf5ff 100644 --- a/Gems/LmbrCentral/Code/Tests/CylinderShapeTest.cpp +++ b/Gems/LmbrCentral/Code/Tests/CylinderShapeTest.cpp @@ -138,7 +138,7 @@ namespace UnitTest { AZ::Transform::CreateTranslation(AZ::Vector3(-14.0f, -14.0f, -1.0f)) * AZ::Transform::CreateRotationY(AZ::Constants::HalfPi) * AZ::Transform::CreateRotationZ(AZ::Constants::HalfPi) * - AZ::Transform::CreateScale(AZ::Vector3(4.0f)), + AZ::Transform::CreateUniformScale(4.0f), 1.0f, 1.25f }, // Result: hit, distance, epsilon { true, 2.5f, 1e-2f } @@ -203,7 +203,7 @@ namespace UnitTest // Test case 2 { // Cylinder: transform, radius, height { AZ::Transform::CreateTranslation(AZ::Vector3(-10.0f, -10.0f, 10.0f)) * - AZ::Transform::CreateScale(AZ::Vector3(3.5f)), + AZ::Transform::CreateUniformScale(3.5f), 1.0f, 5.0f }, // AABB: min, max { AZ::Vector3(-13.5f, -13.5f, 1.25f), AZ::Vector3(-6.5f, -6.5f, 18.75f) } }, @@ -236,7 +236,7 @@ namespace UnitTest { AZ::Vector3(-5.0f, -5.0f, -0.5f), AZ::Vector3(5.0f, 5.0f, 0.5f) } }, // Test case 1 { // Cylinder: transform, radius, height - { AZ::Transform::CreateTranslation(AZ::Vector3(-10.0f, -10.0f, 10.0f)) * AZ::Transform::CreateScale(AZ::Vector3(3.5f)), + { AZ::Transform::CreateTranslation(AZ::Vector3(-10.0f, -10.0f, 10.0f)) * AZ::Transform::CreateUniformScale(3.5f), 5.0f, 5.0f }, // Local bounds: min, max { AZ::Vector3(-5.0f, -5.0f, -2.5f), AZ::Vector3(5.0f, 5.0f, 2.5f) } }, @@ -264,7 +264,7 @@ namespace UnitTest // Test case 0 { // Cylinder: transform, radius, height {AZ::Transform::CreateTranslation(AZ::Vector3(27.0f, 28.0f, 38.0f)) * - AZ::Transform::CreateScale(AZ::Vector3(2.5f, 1.0f, 1.0f)), // test max scale + AZ::Transform::CreateUniformScale(2.5f), 0.5f, 2.0f}, // Point AZ::Vector3(27.0f, 28.5f, 40.0f), @@ -275,7 +275,7 @@ namespace UnitTest {AZ::Transform::CreateTranslation(AZ::Vector3(27.0f, 28.0f, 38.0f)) * AZ::Transform::CreateRotationX(AZ::Constants::HalfPi) * AZ::Transform::CreateRotationY(AZ::Constants::QuarterPi) * - AZ::Transform::CreateScale(AZ::Vector3(0.5f)), + AZ::Transform::CreateUniformScale(0.5f), 0.5f, 2.0f}, // Point AZ::Vector3(27.0f, 28.155f, 37.82f), @@ -316,7 +316,7 @@ namespace UnitTest { AZ::Transform::CreateTranslation(AZ::Vector3(27.0f, 28.0f, 38.0f)) * AZ::Transform::CreateRotationX(AZ::Constants::HalfPi) * AZ::Transform::CreateRotationY(AZ::Constants::QuarterPi) * - AZ::Transform::CreateScale(AZ::Vector3(2.0f)), + AZ::Transform::CreateUniformScale(2.0f), 0.5f, 4.0f }, // Point AZ::Vector3(27.0f, 28.0f, 41.0f), @@ -327,7 +327,7 @@ namespace UnitTest { AZ::Transform::CreateTranslation(AZ::Vector3(27.0f, 28.0f, 38.0f)) * AZ::Transform::CreateRotationX(AZ::Constants::HalfPi) * AZ::Transform::CreateRotationY(AZ::Constants::QuarterPi) * - AZ::Transform::CreateScale(AZ::Vector3(2.0f)), + AZ::Transform::CreateUniformScale(2.0f), 0.5f, 4.0f }, // Point AZ::Vector3(22.757f, 32.243f, 38.0f), diff --git a/Gems/LmbrCentral/Code/Tests/DiskShapeTest.cpp b/Gems/LmbrCentral/Code/Tests/DiskShapeTest.cpp index 4a39cd966e..c3683cc33b 100644 --- a/Gems/LmbrCentral/Code/Tests/DiskShapeTest.cpp +++ b/Gems/LmbrCentral/Code/Tests/DiskShapeTest.cpp @@ -307,7 +307,7 @@ namespace UnitTest AZ::Entity entity; CreateDisk( AZ::Transform::CreateTranslation(AZ::Vector3(100.0f, 200.0f, 300.0f)) * - AZ::Transform::CreateScale(AZ::Vector3(2.5f)), + AZ::Transform::CreateUniformScale(2.5f), 0.5f, entity); AZ::Aabb aabb; diff --git a/Gems/LmbrCentral/Code/Tests/PolygonPrismShapeTest.cpp b/Gems/LmbrCentral/Code/Tests/PolygonPrismShapeTest.cpp index 46c3da90ab..f12ca69425 100644 --- a/Gems/LmbrCentral/Code/Tests/PolygonPrismShapeTest.cpp +++ b/Gems/LmbrCentral/Code/Tests/PolygonPrismShapeTest.cpp @@ -329,7 +329,7 @@ namespace UnitTest AZ::Entity entity; AZ::Transform transform = AZ::Transform::CreateFromQuaternionAndTranslation( AZ::Quaternion::CreateRotationY(AZ::DegToRad(45.0f)), AZ::Vector3(3.0f, 4.0f, 5.0f)); - transform.MultiplyByScale(AZ::Vector3(1.5f, 1.5f, 1.5f)); + transform.MultiplyByUniformScale(1.5f); const float height = 1.2f; const AZ::Vector3 nonUniformScale(2.0f, 1.2f, 0.5f); const AZStd::vector vertices = @@ -447,7 +447,7 @@ namespace UnitTest AZ::Entity entity; AZ::Transform transform = AZ::Transform::CreateFromQuaternionAndTranslation( AZ::Quaternion::CreateRotationY(AZ::DegToRad(45.0f)), AZ::Vector3(3.0f, 4.0f, 5.0f)); - transform.MultiplyByScale(AZ::Vector3(1.5f, 1.5f, 1.5f)); + transform.MultiplyByUniformScale(1.5f); const float height = 1.2f; const AZ::Vector3 nonUniformScale(2.0f, 1.2f, 0.5f); const AZStd::vector vertices = @@ -608,7 +608,7 @@ namespace UnitTest AZ::Entity entity; CreatePolygonPrism( AZ::Transform::CreateTranslation(AZ::Vector3(5.0f, 15.0f, 40.0f)) * - AZ::Transform::CreateScale(AZ::Vector3(3.0f)), 2.0f, + AZ::Transform::CreateUniformScale(3.0f), 2.0f, AZStd::vector( { AZ::Vector2(-2.0f, -2.0f), @@ -669,7 +669,7 @@ namespace UnitTest AZ::Entity entity; AZ::Transform transform = AZ::Transform::CreateFromQuaternionAndTranslation( AZ::Quaternion::CreateRotationY(AZ::DegToRad(60.0f)), AZ::Vector3(1.0f, 2.5f, -1.0f)); - transform.MultiplyByScale(AZ::Vector3(2.0f, 2.0f, 2.0f)); + transform.MultiplyByUniformScale(2.0f); const float height = 1.5f; const AZ::Vector3 nonUniformScale(0.5f, 1.5f, 2.0f); @@ -772,7 +772,7 @@ namespace UnitTest AZ::Entity entity; CreatePolygonPrism( AZ::Transform::CreateTranslation(AZ::Vector3(5.0f, 15.0f, 40.0f)) * - AZ::Transform::CreateScale(AZ::Vector3(3.0f)), 1.5f, + AZ::Transform::CreateUniformScale(3.0f), 1.5f, AZStd::vector( { AZ::Vector2(-2.0f, -2.0f), @@ -795,7 +795,7 @@ namespace UnitTest AZ::Entity entity; AZ::Transform transform = AZ::Transform::CreateFromQuaternionAndTranslation( AZ::Quaternion::CreateRotationX(AZ::DegToRad(30.0f)), AZ::Vector3(2.0f, -5.0f, 3.0f)); - transform.MultiplyByScale(AZ::Vector3(2.0f, 2.0f, 2.0f)); + transform.MultiplyByUniformScale(2.0f); const float height = 1.2f; const AZ::Vector3 nonUniformScale(1.5f, 0.8f, 2.0f); const AZStd::vector vertices = diff --git a/Gems/LmbrCentral/Code/Tests/QuadShapeTest.cpp b/Gems/LmbrCentral/Code/Tests/QuadShapeTest.cpp index d70a9344a4..4b6eae4bb8 100644 --- a/Gems/LmbrCentral/Code/Tests/QuadShapeTest.cpp +++ b/Gems/LmbrCentral/Code/Tests/QuadShapeTest.cpp @@ -188,7 +188,7 @@ namespace UnitTest AZ::Entity entity; AZ::Transform transformIn = AZ::Transform::CreateFromQuaternionAndTranslation( AZ::Quaternion(0.46f, 0.34f, 0.02f, 0.82f), AZ::Vector3(1.7f, -0.4f, 2.3f)); - transformIn.MultiplyByScale(AZ::Vector3(2.2f)); + transformIn.MultiplyByUniformScale(2.2f); const AZ::Vector3 nonUniformScale(0.8f, 0.6f, 1.3f); const float width = 0.7f; const float height = 1.3f; @@ -327,7 +327,7 @@ namespace UnitTest AZ::Entity entity; AZ::Transform transform = AZ::Transform::CreateFromQuaternionAndTranslation( AZ::Quaternion(0.64f, 0.16f, 0.68f, 0.32f), AZ::Vector3(0.4f, -2.3f, -0.9f)); - transform.MultiplyByScale(AZ::Vector3(1.3f)); + transform.MultiplyByUniformScale(1.3f); const AZ::Vector3 nonUniformScale(0.7f, 0.5f, 1.3f); const float width = 0.9f; const float height = 1.3f; @@ -384,7 +384,7 @@ namespace UnitTest AZ::Entity entity; CreateQuad( AZ::Transform::CreateTranslation(AZ::Vector3(100.0f, 200.0f, 300.0f)) * - AZ::Transform::CreateScale(AZ::Vector3(2.5f)), + AZ::Transform::CreateUniformScale(2.5f), 1.0f, 2.0f, entity); AZ::Aabb aabb; @@ -425,7 +425,7 @@ namespace UnitTest AZ::Entity entity; AZ::Transform transform = AZ::Transform::CreateFromQuaternionAndTranslation( AZ::Quaternion(0.44f, 0.24f, 0.48f, 0.72f), AZ::Vector3(3.4f, 1.2f, -2.8f)); - transform.MultiplyByScale(AZ::Vector3(1.5f)); + transform.MultiplyByUniformScale(1.5f); const AZ::Vector3 nonUniformScale(1.2f, 1.1f, 0.8f); const float width = 1.2f; const float height = 1.7f; @@ -518,7 +518,7 @@ namespace UnitTest AZ::Entity entity; AZ::Transform transform = AZ::Transform::CreateFromQuaternionAndTranslation( AZ::Quaternion(0.24f, 0.72f, 0.44f, 0.48f), AZ::Vector3(2.7f, 2.3f, -1.8f)); - transform.MultiplyByScale(AZ::Vector3(1.2f)); + transform.MultiplyByUniformScale(1.2f); const AZ::Vector3 nonUniformScale(0.4f, 2.2f, 1.3f); const float width = 1.6f; const float height = 0.7f; @@ -546,7 +546,7 @@ namespace UnitTest AZ::Entity entity; AZ::Transform transform = AZ::Transform::CreateFromQuaternionAndTranslation( AZ::Quaternion(0.70f, 0.10f, 0.34f, 0.62f), AZ::Vector3(3.0f, -1.0f, 2.0f)); - transform.MultiplyByScale(AZ::Vector3(2.0f)); + transform.MultiplyByUniformScale(2.0f); const AZ::Vector3 nonUniformScale(2.4f, 1.3f, 1.8f); const float width = 0.8f; const float height = 1.4f; diff --git a/Gems/LmbrCentral/Code/Tests/SphereShapeTest.cpp b/Gems/LmbrCentral/Code/Tests/SphereShapeTest.cpp index 563bb16caa..b5e45f2cda 100644 --- a/Gems/LmbrCentral/Code/Tests/SphereShapeTest.cpp +++ b/Gems/LmbrCentral/Code/Tests/SphereShapeTest.cpp @@ -179,7 +179,7 @@ namespace UnitTest AZ::Entity entity; CreateSphere( AZ::Transform::CreateTranslation(AZ::Vector3(-8.0f, -15.0f, 5.0f)) * - AZ::Transform::CreateScale(AZ::Vector3(5.0f)), + AZ::Transform::CreateUniformScale(5.0f), 0.25f, entity); bool rayHit = false; @@ -240,7 +240,7 @@ namespace UnitTest AZ::Entity entity; CreateSphere( AZ::Transform::CreateTranslation(AZ::Vector3(100.0f, 200.0f, 300.0f)) * - AZ::Transform::CreateScale(AZ::Vector3(2.5f)), + AZ::Transform::CreateUniformScale(2.5f), 0.5f, entity); AZ::Aabb aabb; @@ -269,7 +269,7 @@ namespace UnitTest TEST_F(SphereShapeTest, GetTransformAndLocalBounds2) { AZ::Entity entity; - AZ::Transform transformIn = AZ::Transform::CreateTranslation(AZ::Vector3(100.0f, 200.0f, 300.0f)) * AZ::Transform::CreateScale(AZ::Vector3(2.5f)); + AZ::Transform transformIn = AZ::Transform::CreateTranslation(AZ::Vector3(100.0f, 200.0f, 300.0f)) * AZ::Transform::CreateUniformScale(2.5f); CreateSphere(transformIn, 2.0f, entity); AZ::Transform transformOut; @@ -287,7 +287,7 @@ namespace UnitTest AZ::Entity entity; CreateSphere( AZ::Transform::CreateTranslation(AZ::Vector3(-30.0f, -30.0f, 22.0f)) * - AZ::Transform::CreateScale(AZ::Vector3(2.0f)), + AZ::Transform::CreateUniformScale(2.0f), 1.2f, entity); bool inside; @@ -303,7 +303,7 @@ namespace UnitTest AZ::Entity entity; CreateSphere( AZ::Transform::CreateTranslation(AZ::Vector3(-30.0f, -30.0f, 22.0f)) * - AZ::Transform::CreateScale(AZ::Vector3(1.5f)), + AZ::Transform::CreateUniformScale(1.5f), 1.6f, entity); bool inside; @@ -319,7 +319,7 @@ namespace UnitTest AZ::Entity entity; CreateSphere( AZ::Transform::CreateTranslation(AZ::Vector3(19.0f, 34.0f, 37.0f)) * - AZ::Transform::CreateScale(AZ::Vector3(2.0f)), + AZ::Transform::CreateUniformScale(2.0f), 1.0f, entity); float distance; @@ -335,7 +335,7 @@ namespace UnitTest AZ::Entity entity; CreateSphere( AZ::Transform::CreateTranslation(AZ::Vector3(19.0f, 34.0f, 37.0f)) * - AZ::Transform::CreateScale(AZ::Vector3(0.5f)), + AZ::Transform::CreateUniformScale(0.5f), 1.0f, entity); float distance; diff --git a/Gems/LmbrCentral/Code/Tests/TubeShapeTest.cpp b/Gems/LmbrCentral/Code/Tests/TubeShapeTest.cpp index 65388d1fe5..e9d9c40433 100644 --- a/Gems/LmbrCentral/Code/Tests/TubeShapeTest.cpp +++ b/Gems/LmbrCentral/Code/Tests/TubeShapeTest.cpp @@ -139,7 +139,7 @@ namespace UnitTest AZ::Entity entity; CreateTube( AZ::Transform::CreateTranslation(AZ::Vector3(-40.0f, 6.0f, 1.0f)) * - AZ::Transform::CreateScale(AZ::Vector3(2.5f, 1.0f, 1.0f)), // test max scale + AZ::Transform::CreateUniformScale(2.5f), 1.0f, entity); @@ -232,7 +232,7 @@ namespace UnitTest TEST_F(TubeShapeTest, GetAabb4) { AZ::Entity entity; - CreateTube(AZ::Transform::CreateScale(AZ::Vector3(1.0f, 1.0f, 2.0f)), 1.0f, entity); + CreateTube(AZ::Transform::CreateUniformScale(2.0f), 1.0f, entity); // set variable radius LmbrCentral::TubeShapeComponentRequestsBus::Event( @@ -254,7 +254,7 @@ namespace UnitTest AZ::Entity entity; CreateTube( AZ::Transform::CreateTranslation(AZ::Vector3(37.0f, 36.0f, 32.0f)) * - AZ::Transform::CreateScale(AZ::Vector3(1.0f, 2.0f, 1.0f)), 1.5f, entity); + AZ::Transform::CreateUniformScale(2.0f), 1.5f, entity); // set variable radius LmbrCentral::TubeShapeComponentRequestsBus::Event( @@ -277,7 +277,7 @@ namespace UnitTest AZ::Transform::CreateTranslation(AZ::Vector3(37.0f, 36.0f, 32.0f)) * AZ::Transform::CreateRotationZ(AZ::Constants::QuarterPi) * AZ::Transform::CreateRotationY(AZ::Constants::QuarterPi) * - AZ::Transform::CreateScale(AZ::Vector3(0.8f, 1.5f, 1.5f)), 1.5f, entity); + AZ::Transform::CreateUniformScale(1.5f), 1.5f, entity); // set variable radius LmbrCentral::TubeShapeComponentRequestsBus::Event( @@ -302,7 +302,7 @@ namespace UnitTest AZ::Entity entity; CreateTube( AZ::Transform::CreateTranslation(AZ::Vector3(37.0f, 36.0f, 39.0f)) * - AZ::Transform::CreateScale(AZ::Vector3(2.0f, 1.5f, 1.5f)), 1.5f, entity); + AZ::Transform::CreateUniformScale(2.0f), 1.5f, entity); LmbrCentral::TubeShapeComponentRequestsBus::Event( entity.GetId(), &LmbrCentral::TubeShapeComponentRequestsBus::Events::SetVariableRadius, 0, 1.0f); @@ -326,7 +326,7 @@ namespace UnitTest AZ::Entity entity; CreateTube( AZ::Transform::CreateTranslation(AZ::Vector3(37.0f, 36.0f, 39.0f)) * - AZ::Transform::CreateScale(AZ::Vector3(2.0f, 1.5f, 1.5f)), 1.5f, entity); + AZ::Transform::CreateUniformScale(2.0f), 1.5f, entity); LmbrCentral::TubeShapeComponentRequestsBus::Event( entity.GetId(), &LmbrCentral::TubeShapeComponentRequestsBus::Events::SetVariableRadius, 0, 1.0f); diff --git a/Gems/PhysX/Code/Source/RigidBodyComponent.cpp b/Gems/PhysX/Code/Source/RigidBodyComponent.cpp index f770f8408c..feb35ea07d 100644 --- a/Gems/PhysX/Code/Source/RigidBodyComponent.cpp +++ b/Gems/PhysX/Code/Source/RigidBodyComponent.cpp @@ -201,9 +201,8 @@ namespace PhysX AZ::Quaternion newRotation = AZ::Quaternion::CreateIdentity(); m_interpolator->GetInterpolated(newPosition, newRotation, deltaTime); - AZ::Transform interpolatedTransform = AZ::Transform::CreateFromQuaternionAndTranslation(newRotation, newPosition); - interpolatedTransform.MultiplyByScale(m_initialScale); - AZ::TransformBus::Event(GetEntityId(), &AZ::TransformInterface::SetWorldTM, interpolatedTransform); + AZ::TransformBus::Event(GetEntityId(), &AZ::TransformInterface::SetRotationQuaternion, newRotation); + AZ::TransformBus::Event(GetEntityId(), &AZ::TransformInterface::SetWorldTranslation, newPosition); } } @@ -257,12 +256,8 @@ namespace PhysX } else { - // Maintain scale (this must be precise). - AZ::Transform entityTransform = AZ::Transform::Identity(); - AZ::TransformBus::EventResult(entityTransform, GetEntityId(), &AZ::TransformInterface::GetWorldTM); - transform.MultiplyByScale(m_initialScale); - - AZ::TransformBus::Event(GetEntityId(), &AZ::TransformInterface::SetWorldTM, transform); + AZ::TransformBus::Event(GetEntityId(), &AZ::TransformInterface::SetRotationQuaternion, rigidBody->GetOrientation()); + AZ::TransformBus::Event(GetEntityId(), &AZ::TransformInterface::SetWorldTranslation, rigidBody->GetPosition()); } m_isLastMovementFromKinematicSource = false; } @@ -353,8 +348,6 @@ namespace PhysX m_interpolator = std::make_unique(); m_interpolator->Reset(transform.GetTranslation(), rotation); - m_initialScale = transform.ExtractScale(); - Physics::RigidBodyNotificationBus::Event(GetEntityId(), &Physics::RigidBodyNotificationBus::Events::OnPhysicsEnabled); } diff --git a/Gems/PhysX/Code/Source/RigidBodyComponent.h b/Gems/PhysX/Code/Source/RigidBodyComponent.h index 7b2a34cf37..07fa4fb847 100644 --- a/Gems/PhysX/Code/Source/RigidBodyComponent.h +++ b/Gems/PhysX/Code/Source/RigidBodyComponent.h @@ -161,7 +161,6 @@ namespace PhysX AzPhysics::SimulatedBodyHandle m_rigidBodyHandle = AzPhysics::InvalidSimulatedBodyHandle; AzPhysics::SceneHandle m_attachedSceneHandle = AzPhysics::InvalidSceneHandle; - AZ::Vector3 m_initialScale = AZ::Vector3::CreateOne(); bool m_staticTransformAtActivation = false; ///< Whether the transform was static when the component last activated. bool m_isLastMovementFromKinematicSource = false; ///< True when the source of the movement comes from SetKinematicTarget as opposed to coming from a Transform change bool m_rigidBodyTransformNeedsUpdateOnPhysReEnable = false; ///< True if rigid body transform needs to be synced to the entity's when physics is re-enabled diff --git a/Gems/PhysX/Code/Tests/ColliderScalingTests.cpp b/Gems/PhysX/Code/Tests/ColliderScalingTests.cpp index 25747a55f6..19d069331a 100644 --- a/Gems/PhysX/Code/Tests/ColliderScalingTests.cpp +++ b/Gems/PhysX/Code/Tests/ColliderScalingTests.cpp @@ -68,7 +68,7 @@ namespace PhysXEditorTests AZ::EntityId editorId = editorEntity->GetId(); AZ::Transform worldTM; - worldTM.SetScale(AZ::Vector3(1.5f)); + worldTM.SetUniformScale(1.5f); worldTM.SetTranslation(AZ::Vector3(5.0f, 6.0f, 7.0f)); worldTM.SetRotation(AZ::Quaternion::CreateRotationX(AZ::DegToRad(30.0f))); AZ::TransformBus::Event(editorId, &AZ::TransformBus::Events::SetWorldTM, worldTM); @@ -99,7 +99,7 @@ namespace PhysXEditorTests AZ::EntityId editorId = editorEntity->GetId(); AZ::Transform worldTM; - worldTM.SetScale(AZ::Vector3(1.5f)); + worldTM.SetUniformScale(1.5f); worldTM.SetTranslation(AZ::Vector3(5.0f, 6.0f, 7.0f)); worldTM.SetRotation(AZ::Quaternion::CreateRotationX(AZ::DegToRad(30.0f))); AZ::TransformBus::Event(editorId, &AZ::TransformBus::Events::SetWorldTM, worldTM); @@ -144,7 +144,7 @@ namespace PhysXEditorTests AZ::EntityId capsuleId = editorEntity->GetId(); AZ::Transform worldTM; - worldTM.SetScale(AZ::Vector3(0.5f)); + worldTM.SetUniformScale(0.5f); worldTM.SetTranslation(AZ::Vector3(3.0f, 1.0f, -4.0f)); worldTM.SetRotation(AZ::Quaternion::CreateRotationY(AZ::DegToRad(90.0f))); AZ::TransformBus::Event(capsuleId, &AZ::TransformBus::Events::SetWorldTM, worldTM); @@ -176,7 +176,7 @@ namespace PhysXEditorTests AZ::EntityId capsuleId = editorEntity->GetId(); AZ::Transform worldTM; - worldTM.SetScale(AZ::Vector3(0.5f)); + worldTM.SetUniformScale(0.5f); worldTM.SetTranslation(AZ::Vector3(3.0f, 1.0f, -4.0f)); worldTM.SetRotation(AZ::Quaternion::CreateRotationY(AZ::DegToRad(90.0f))); AZ::TransformBus::Event(capsuleId, &AZ::TransformBus::Events::SetWorldTM, worldTM); @@ -222,7 +222,7 @@ namespace PhysXEditorTests AZ::EntityId sphereId = editorEntity->GetId(); AZ::Transform worldTM; - worldTM.SetScale(AZ::Vector3(1.2f)); + worldTM.SetUniformScale(1.2f); worldTM.SetTranslation(AZ::Vector3(-2.0f, -1.0f, 3.0f)); worldTM.SetRotation(AZ::Quaternion::CreateRotationX(AZ::DegToRad(90.0f))); AZ::TransformBus::Event(sphereId, &AZ::TransformBus::Events::SetWorldTM, worldTM); @@ -254,7 +254,7 @@ namespace PhysXEditorTests AZ::EntityId sphereId = editorEntity->GetId(); AZ::Transform worldTM; - worldTM.SetScale(AZ::Vector3(1.2f)); + worldTM.SetUniformScale(1.2f); worldTM.SetTranslation(AZ::Vector3(-2.0f, -1.0f, 3.0f)); worldTM.SetRotation(AZ::Quaternion::CreateRotationX(AZ::DegToRad(90.0f))); AZ::TransformBus::Event(sphereId, &AZ::TransformBus::Events::SetWorldTM, worldTM); diff --git a/Gems/PhysX/Code/Tests/DebugDrawTests.cpp b/Gems/PhysX/Code/Tests/DebugDrawTests.cpp index 5b41c37f34..610ba8d6f6 100644 --- a/Gems/PhysX/Code/Tests/DebugDrawTests.cpp +++ b/Gems/PhysX/Code/Tests/DebugDrawTests.cpp @@ -32,7 +32,7 @@ namespace PhysXEditorTests AZ::EntityId boxId = boxEntity->GetId(); AZ::Transform worldTM; - worldTM.SetScale(AZ::Vector3(1.5f)); + worldTM.SetUniformScale(1.5f); worldTM.SetTranslation(AZ::Vector3(5.0f, 6.0f, 7.0f)); worldTM.SetRotation(AZ::Quaternion::CreateRotationX(AZ::DegToRad(30.0f))); AZ::TransformBus::Event(boxId, &AZ::TransformBus::Events::SetWorldTM, worldTM); @@ -61,7 +61,7 @@ namespace PhysXEditorTests AZ::EntityId boxId = boxEntity->GetId(); AZ::Transform worldTM; - worldTM.SetScale(AZ::Vector3(1.2f)); + worldTM.SetUniformScale(1.2f); worldTM.SetTranslation(AZ::Vector3(4.0f, -3.0f, 1.0f)); worldTM.SetRotation(AZ::Quaternion::CreateRotationZ(AZ::DegToRad(45.0f))); AZ::TransformBus::Event(boxId, &AZ::TransformBus::Events::SetWorldTM, worldTM); @@ -91,7 +91,7 @@ namespace PhysXEditorTests AZ::EntityId boxId = boxEntity->GetId(); AZ::Transform worldTM; - worldTM.SetScale(AZ::Vector3(1.2f)); + worldTM.SetUniformScale(1.2f); worldTM.SetTranslation(AZ::Vector3(4.0f, -3.0f, 1.0f)); worldTM.SetRotation(AZ::Quaternion::CreateRotationZ(AZ::DegToRad(45.0f))); AZ::TransformBus::Event(boxId, &AZ::TransformBus::Events::SetWorldTM, worldTM); @@ -129,7 +129,7 @@ namespace PhysXEditorTests AZ::EntityId capsuleId = capsuleEntity->GetId(); AZ::Transform worldTM; - worldTM.SetScale(AZ::Vector3(0.5f)); + worldTM.SetUniformScale(0.5f); worldTM.SetTranslation(AZ::Vector3(3.0f, 1.0f, -4.0f)); worldTM.SetRotation(AZ::Quaternion::CreateRotationY(AZ::DegToRad(90.0f))); AZ::TransformBus::Event(capsuleId, &AZ::TransformBus::Events::SetWorldTM, worldTM); @@ -158,7 +158,7 @@ namespace PhysXEditorTests AZ::EntityId capsuleId = capsuleEntity->GetId(); AZ::Transform worldTM; - worldTM.SetScale(AZ::Vector3(1.4f)); + worldTM.SetUniformScale(1.4f); worldTM.SetTranslation(AZ::Vector3(1.0f, -4.0f, 4.0f)); worldTM.SetRotation(AZ::Quaternion::CreateRotationX(AZ::DegToRad(45.0f))); AZ::TransformBus::Event(capsuleId, &AZ::TransformBus::Events::SetWorldTM, worldTM); @@ -189,7 +189,7 @@ namespace PhysXEditorTests AZ::EntityId sphereId = sphereEntity->GetId(); AZ::Transform worldTM; - worldTM.SetScale(AZ::Vector3(1.2f)); + worldTM.SetUniformScale(1.2f); worldTM.SetTranslation(AZ::Vector3(-2.0f, -1.0f, 3.0f)); worldTM.SetRotation(AZ::Quaternion::CreateRotationX(AZ::DegToRad(90.0f))); AZ::TransformBus::Event(sphereId, &AZ::TransformBus::Events::SetWorldTM, worldTM); @@ -218,7 +218,7 @@ namespace PhysXEditorTests AZ::EntityId sphereId = sphereEntity->GetId(); AZ::Transform worldTM; - worldTM.SetScale(AZ::Vector3(0.8f)); + worldTM.SetUniformScale(0.8f); worldTM.SetTranslation(AZ::Vector3(2.0f, -1.0f, 3.0f)); worldTM.SetRotation(AZ::Quaternion::CreateRotationY(AZ::DegToRad(45.0f))); AZ::TransformBus::Event(sphereId, &AZ::TransformBus::Events::SetWorldTM, worldTM); diff --git a/Gems/PhysX/Code/Tests/EditorTestUtilities.cpp b/Gems/PhysX/Code/Tests/EditorTestUtilities.cpp index 043bd60acd..c2e0bbbf5e 100644 --- a/Gems/PhysX/Code/Tests/EditorTestUtilities.cpp +++ b/Gems/PhysX/Code/Tests/EditorTestUtilities.cpp @@ -93,39 +93,43 @@ namespace PhysXEditorTests editorEntity->CreateComponent(); editorEntity->CreateComponent(LmbrCentral::EditorCylinderShapeComponentTypeId); editorEntity->Activate(); - + { - UnitTest::ErrorHandler warningHandler("Negative or zero cylinder dimensions are invalid"); + UnitTest::ErrorHandler dimensionWarningHandler("Negative or zero cylinder dimensions are invalid"); + UnitTest::ErrorHandler colliderWarningHandler("No Collider or Shape information found when creating Rigid body"); LmbrCentral::CylinderShapeComponentRequestsBus::Event(editorEntity->GetId(), &LmbrCentral::CylinderShapeComponentRequests::SetRadius, radius); // expect 2 warnings //1 if the radius is invalid //2 when re-creating the underlying simulated body - int expectedWarningCount = radius <= 0.f ? 2 : 0; - EXPECT_EQ(warningHandler.GetWarningCount(), expectedWarningCount); + int expectedWarningCount = radius <= 0.f ? 1 : 0; + EXPECT_EQ(dimensionWarningHandler.GetExpectedWarningCount(), expectedWarningCount); + EXPECT_EQ(colliderWarningHandler.GetExpectedWarningCount(), expectedWarningCount); } - + { - UnitTest::ErrorHandler warningHandler("Negative or zero cylinder dimensions are invalid"); + UnitTest::ErrorHandler dimensionWarningHandler("Negative or zero cylinder dimensions are invalid"); + UnitTest::ErrorHandler colliderWarningHandler("No Collider or Shape information found when creating Rigid body"); LmbrCentral::CylinderShapeComponentRequestsBus::Event(editorEntity->GetId(), &LmbrCentral::CylinderShapeComponentRequests::SetHeight, height); // expect 2 warnings //1 if the radius or height is invalid //2 when re-creating the underlying simulated body - int expectedWarningCount = radius <= 0.f || height <= 0.f ? 2 : 0; - EXPECT_EQ(warningHandler.GetWarningCount(), expectedWarningCount); + int expectedWarningCount = radius <= 0.f || height <= 0.f ? 1 : 0; + EXPECT_EQ(dimensionWarningHandler.GetExpectedWarningCount(), expectedWarningCount); + EXPECT_EQ(colliderWarningHandler.GetExpectedWarningCount(), expectedWarningCount); } EntityPtr gameEntity = CreateActiveGameEntityFromEditorEntity(editorEntity.get()); - + // since there was no editor rigid body component, the runtime entity should have a static rigid body const auto* staticBody = azdynamic_cast(gameEntity->FindComponent()->GetSimulatedBody()); const auto* pxRigidStatic = static_cast(staticBody->GetNativePointer()); - + PHYSX_SCENE_READ_LOCK(pxRigidStatic->getScene()); - + // there should be no shapes on the rigid body because the cylinder radius and/or height is invalid EXPECT_EQ(pxRigidStatic->getNbShapes(), 0); } diff --git a/Gems/PhysX/Code/Tests/RigidBodyComponentTests.cpp b/Gems/PhysX/Code/Tests/RigidBodyComponentTests.cpp index eee747d390..4ff88c0b3b 100644 --- a/Gems/PhysX/Code/Tests/RigidBodyComponentTests.cpp +++ b/Gems/PhysX/Code/Tests/RigidBodyComponentTests.cpp @@ -38,8 +38,8 @@ namespace PhysXEditorTests const AZ::Aabb originalAabb = rigidBodyComponent->GetRigidBody()->GetAabb(); // Update the scale - const AZ::Vector3 scale(2.0f); - AZ::TransformBus::Event(editorEntity->GetId(), &AZ::TransformInterface::SetLocalScale, scale); + float scale = 2.0f; + AZ::TransformBus::Event(editorEntity->GetId(), &AZ::TransformInterface::SetLocalUniformScale, scale); // Trigger editor physics world update so EditorRigidBodyComponent can process scale change auto* physicsSystem = AZ::Interface::Get(); @@ -89,8 +89,8 @@ namespace PhysXEditorTests idPair, &PhysX::EditorColliderComponentRequests::SetColliderOffset, offset); // Update the scale - const AZ::Vector3 scale(2.0f); - AZ::TransformBus::Event(editorEntity->GetId(), &AZ::TransformInterface::SetLocalScale, scale); + float scale = 2.0f; + AZ::TransformBus::Event(editorEntity->GetId(), &AZ::TransformInterface::SetLocalUniformScale, scale); // Update editor world to let updates to be applied physicsSystem->Simulate(0.1f); diff --git a/Gems/PhysX/Code/Tests/ShapeColliderComponentTests.cpp b/Gems/PhysX/Code/Tests/ShapeColliderComponentTests.cpp index b00e226078..c8ab158d77 100644 --- a/Gems/PhysX/Code/Tests/ShapeColliderComponentTests.cpp +++ b/Gems/PhysX/Code/Tests/ShapeColliderComponentTests.cpp @@ -241,7 +241,7 @@ namespace PhysXEditorTests SetPolygonPrismHeight(entityId, 2.0f); // update the transform scale and non-uniform scale - AZ::TransformBus::Event(entityId, &AZ::TransformBus::Events::SetScale, AZ::Vector3(2.0f)); + AZ::TransformBus::Event(entityId, &AZ::TransformBus::Events::SetLocalUniformScale, 2.0f); AZ::NonUniformScaleRequestBus::Event(entityId, &AZ::NonUniformScaleRequests::SetScale, AZ::Vector3(0.5f, 1.5f, 2.0f)); EntityPtr gameEntity = CreateActiveGameEntityFromEditorEntity(editorEntity.get()); @@ -347,6 +347,7 @@ namespace PhysXEditorTests TEST_F(PhysXEditorFixture, EditorShapeColliderComponent_ShapeColliderWithUnsupportedShape_HandledGracefully) { UnitTest::ErrorHandler unsupportedShapeWarningHandler("Unsupported shape"); + UnitTest::ErrorHandler rigidBodyWarningHandler("No Collider or Shape information found when creating Rigid body"); // create an editor entity with a shape collider component and a cylinder shape component // the cylinder shape is not currently supported by the shape collider component @@ -355,10 +356,8 @@ namespace PhysXEditorTests editorEntity->CreateComponent(LmbrCentral::EditorCompoundShapeComponentTypeId); editorEntity->Activate(); - // expect 2 warnings - //1 raised for the unsupported shape - //2 when re-creating the underlying simulated body - EXPECT_EQ(unsupportedShapeWarningHandler.GetWarningCount(), 2); + EXPECT_EQ(unsupportedShapeWarningHandler.GetExpectedWarningCount(), 1); + EXPECT_EQ(rigidBodyWarningHandler.GetExpectedWarningCount(), 1); EntityPtr gameEntity = CreateActiveGameEntityFromEditorEntity(editorEntity.get()); @@ -435,8 +434,8 @@ namespace PhysXEditorTests &LmbrCentral::BoxShapeComponentRequests::GetBoxDimensions); // update the transform - const AZ::Vector3 scale(2.0f); - AZ::TransformBus::Event(editorEntityId, &AZ::TransformInterface::SetLocalScale, scale); + const float scale = 2.0f; + AZ::TransformBus::Event(editorEntityId, &AZ::TransformInterface::SetLocalUniformScale, scale); const AZ::Vector3 translation(10.0f, 20.0f, 30.0f); AZ::TransformBus::Event(editorEntityId, &AZ::TransformInterface::SetWorldTranslation, translation); @@ -527,10 +526,8 @@ namespace PhysXEditorTests editorParentEntity->Activate(); // set some scale to parent entity - const AZ::Vector3 parentScale(2.0f); - AZ::TransformBus::Event(editorParentEntity->GetId(), - &AZ::TransformInterface::SetLocalScale, - parentScale); + const float parentScale = 2.0f; + AZ::TransformBus::Event(editorParentEntity->GetId(), &AZ::TransformInterface::SetLocalUniformScale, parentScale); // create an editor child entity with a shape collider component and a box shape component EntityPtr editorChildEntity = CreateInactiveEditorEntity("ChildEntity"); diff --git a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Entity/Rotate.cpp b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Entity/Rotate.cpp index c510b55314..2f79d4218a 100644 --- a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Entity/Rotate.cpp +++ b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Entity/Rotate.cpp @@ -47,21 +47,10 @@ namespace ScriptCanvas AZ::Transform currentTransform = AZ::Transform::CreateIdentity(); AZ::TransformBus::EventResult(currentTransform, targetEntity, &AZ::TransformInterface::GetWorldTM); - - AZ::Vector3 position = currentTransform.GetTranslation(); - AZ::Quaternion currentRotation = currentTransform.GetRotation(); + currentTransform.SetRotation((rotation * currentTransform.GetRotation().GetNormalized())); - AZ::Quaternion newRotation = (rotation * currentRotation); - newRotation.Normalize(); - - AZ::Transform newTransform = AZ::Transform::CreateIdentity(); - - newTransform.SetScale(currentTransform.GetScale()); - newTransform.SetRotation(newRotation); - newTransform.SetTranslation(position); - - AZ::TransformBus::Event(targetEntity, &AZ::TransformInterface::SetWorldTM, newTransform); + AZ::TransformBus::Event(targetEntity, &AZ::TransformInterface::SetWorldTM, currentTransform); } } diff --git a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Entity/RotateMethod.cpp b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Entity/RotateMethod.cpp index 20ea4e1b33..53884f4dd8 100644 --- a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Entity/RotateMethod.cpp +++ b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Entity/RotateMethod.cpp @@ -44,22 +44,12 @@ namespace ScriptCanvas { AZ::Quaternion rotation = AZ::ConvertEulerDegreesToQuaternion(angles); - AZ::Transform currentTransform = AZ::Transform::CreateIdentity(); - AZ::TransformBus::EventResult(currentTransform, targetEntity, &AZ::TransformInterface::GetWorldTM); + AZ::Transform transform = AZ::Transform::CreateIdentity(); + AZ::TransformBus::EventResult(transform, targetEntity, &AZ::TransformInterface::GetWorldTM); - AZ::Vector3 position = currentTransform.GetTranslation(); - AZ::Quaternion currentRotation = currentTransform.GetRotation(); + transform.SetRotation((rotation * transform.GetRotation()).GetNormalized()); - AZ::Quaternion newRotation = (rotation * currentRotation); - newRotation.Normalize(); - - AZ::Transform newTransform = AZ::Transform::CreateIdentity(); - - newTransform.CreateScale(currentTransform.ExtractScale()); - newTransform.SetRotation(newRotation); - newTransform.SetTranslation(position); - - AZ::TransformBus::Event(targetEntity, &AZ::TransformInterface::SetWorldTM, newTransform); + AZ::TransformBus::Event(targetEntity, &AZ::TransformInterface::SetWorldTM, transform); } } } diff --git a/Gems/StartingPointCamera/Code/Source/CameraLookAtBehaviors/RotateCameraLookAt.cpp b/Gems/StartingPointCamera/Code/Source/CameraLookAtBehaviors/RotateCameraLookAt.cpp index 2ab7e0bd01..e2e818f3e7 100644 --- a/Gems/StartingPointCamera/Code/Source/CameraLookAtBehaviors/RotateCameraLookAt.cpp +++ b/Gems/StartingPointCamera/Code/Source/CameraLookAtBehaviors/RotateCameraLookAt.cpp @@ -58,19 +58,9 @@ namespace Camera float axisPolarity = m_shouldInvertAxis ? -1.0f : 1.0f; float rotationAmount = axisPolarity * m_rotationAmount; - // remove translation and scale - AZ::Vector3 translation = outLookAtTargetTransform.GetTranslation(); - outLookAtTargetTransform.SetTranslation(AZ::Vector3::CreateZero()); - AZ::Vector3 transformScale = outLookAtTargetTransform.ExtractScale(); - - // perform our rotation - AZ::Transform desiredRotationTransform = AZ::Transform::CreateFromQuaternion(AZ::Quaternion::CreateFromAxisAngle(outLookAtTargetTransform.GetBasis(m_axisOfRotation), rotationAmount)); - - outLookAtTargetTransform = desiredRotationTransform * outLookAtTargetTransform; - - // return scale and translate - outLookAtTargetTransform.SetScale(transformScale); - outLookAtTargetTransform.SetTranslation(translation); + AZ::Quaternion desiredRotation = AZ::Quaternion::CreateFromAxisAngle( + outLookAtTargetTransform.GetBasis(m_axisOfRotation), rotationAmount); + outLookAtTargetTransform.SetRotation(desiredRotation * outLookAtTargetTransform.GetRotation()); } void RotateCameraLookAt::Activate(AZ::EntityId entityId)