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

first pass of changing transform to use float for scale internally rather than Vector3

Browse Source
This commit is contained in:
greerdv
2021-04-27 18:12:46 +01:00
parent 540f0dcd98
commit b113f09a71
76 changed files with 487 additions and 546 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Code/CryEngine/CryCommon/IMovieSystem.h
+2 -2
View File
@@ -696,7 +696,7 @@ public:
//! Rotate entity node.
virtual void SetRotate(float time, const Quat& quat) = 0;
//! Scale entity node.
virtual void SetScale(float time, const Vec3& scale) = 0;
virtual void SetScale(float time, const float scale) = 0;
//! Compute and return the offset which brings the current position to the given position
virtual Vec3 GetOffsetPosition(const Vec3& position) { return position - GetPos(); }
@@ -708,7 +708,7 @@ public:
//! Get entity rotation at specified time.
virtual Quat GetRotate(float time) = 0;
//! Get current entity scale.
virtual Vec3 GetScale() = 0;
virtual float GetScale() = 0;
// General Set param.
// Set float/vec3/vec4 parameter at given time.
Code/Framework/AzCore/AzCore/Component/TransformBus.h
+15 -7
View File
@@ -288,18 +288,26 @@ namespace AZ
//! Scale modifiers
//! @{
//! 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) {}
//! 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); }
virtual void SetLocalUniformScale([[maybe_unused]] float scale) {}
virtual float GetLocalUniformScale() { return FLT_MAX; }
virtual float GetWorldUniformScale() { return FLT_MAX; }
//! @}
//! Transform hierarchy
Code/Framework/AzCore/AzCore/Math/Spline.h
+2 -2
View File
@@ -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);
}
Code/Framework/AzCore/AzCore/Math/Transform.cpp
+7 -7
View File
@@ -130,7 +130,7 @@ namespace AZ
const Transform* transform = reinterpret_cast<const Transform*>(classPtr);
float data[NumFloats];
transform->GetRotation().StoreToFloat4(data);
transform->GetScale().StoreToFloat3(&data[4]);
Vector3(transform->GetScale()).StoreToFloat3(&data[4]);
transform->GetTranslation().StoreToFloat3(&data[7]);
for (int i = 0; i < NumFloats; i++)
@@ -220,7 +220,7 @@ namespace AZ
Vector3 translation = Vector3::CreateFromFloat3(&data[7]);
*reinterpret_cast<Transform*>(classPtr) =
Transform::CreateFromQuaternionAndTranslation(rotation, translation) * Transform::CreateScale(scale);
Transform::CreateFromQuaternionAndTranslation(rotation, translation) * Transform::CreateUniformScale(scale.GetMaxElement());
return true;
}
@@ -250,7 +250,7 @@ namespace AZ
Attribute(Script::Attributes::ExcludeFrom, Script::Attributes::ExcludeFlags::All)->
Attribute(Script::Attributes::Storage, Script::Attributes::StorageType::Value)->
Attribute(Script::Attributes::GenericConstructorOverride, &Internal::TransformDefaultConstructor)->
Constructor<const Vector3&, const Quaternion&, const Vector3&>()->
Constructor<const Vector3&, const Quaternion&, const float>()->
Method("GetBasis", &Transform::GetBasis)->
Method("GetBasisX", &Transform::GetBasisX)->
Method("GetBasisY", &Transform::GetBasisY)->
@@ -284,7 +284,7 @@ namespace AZ
Method("GetRotation", &Transform::GetRotation)->
Method<void (Transform::*)(const Quaternion&)>("SetRotation", &Transform::SetRotation)->
Method("GetScale", &Transform::GetScale)->
Method<void (Transform::*)(const Vector3&)>("SetScale", &Transform::SetScale)->
Method<void (Transform::*)(const Vector3&)>("SetScale", static_cast<void(Transform::*)(const Vector3&)>(&Transform::SetScale))->
Method("ExtractScale", &Transform::ExtractScale)->
Attribute(Script::Attributes::ExcludeFrom, Script::Attributes::ExcludeFlags::All)->
Method("MultiplyByScale", &Transform::MultiplyByScale)->
@@ -315,7 +315,7 @@ namespace AZ
{
Transform result;
Matrix3x3 tmp = value;
result.m_scale = tmp.ExtractScale();
result.m_scale = tmp.ExtractScale().GetMaxElement();
result.m_rotation = Quaternion::CreateFromMatrix3x3(tmp);
result.m_translation = Vector3::CreateZero();
return result;
@@ -325,7 +325,7 @@ namespace AZ
{
Transform result;
Matrix3x3 tmp = value;
result.m_scale = tmp.ExtractScale();
result.m_scale = tmp.ExtractScale().GetMaxElement();
result.m_rotation = Quaternion::CreateFromMatrix3x3(tmp);
result.m_translation = p;
return result;
@@ -335,7 +335,7 @@ namespace AZ
{
Transform result;
Matrix3x4 tmp = value;
result.m_scale = tmp.ExtractScale();
result.m_scale = tmp.ExtractScale().GetMaxElement();
result.m_rotation = Quaternion::CreateFromMatrix3x4(tmp);
result.m_translation = value.GetTranslation();
return result;
Code/Framework/AzCore/AzCore/Math/Transform.h
+16 -7
View File
@@ -63,7 +63,7 @@ namespace AZ
Transform() = default;
//! Construct a transform from components.
Transform(const Vector3& translation, const Quaternion& rotation, const Vector3& scale);
Transform(const Vector3& translation, const Quaternion& rotation, const float scale);
//! Creates an identity transform.
static Transform CreateIdentity();
@@ -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 (uniform) 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);
@@ -159,7 +168,7 @@ namespace AZ
private:
Quaternion m_rotation;
Vector3 m_scale;
float m_scale;
Vector3 m_translation;
};
Code/Framework/AzCore/AzCore/Math/Transform.inl
+57 -21
View File
@@ -12,7 +12,7 @@
namespace AZ
{
AZ_MATH_INLINE Transform::Transform(const Vector3& translation, const Quaternion& rotation, const Vector3& scale)
AZ_MATH_INLINE Transform::Transform(const Vector3& translation, const Quaternion& rotation, const float scale)
: m_translation(translation)
, m_rotation(rotation)
, m_scale(scale)
@@ -25,7 +25,7 @@ namespace AZ
{
Transform result;
result.m_rotation = Quaternion::CreateIdentity();
result.m_scale = Vector3::CreateOne();
result.m_scale = 1.0f;
result.m_translation = Vector3::CreateZero();
return result;
}
@@ -49,7 +49,7 @@ namespace AZ
{
Transform result;
result.m_rotation = q;
result.m_scale = Vector3::CreateOne();
result.m_scale = 1.0f;
result.m_translation = Vector3::CreateZero();
return result;
}
@@ -58,12 +58,22 @@ namespace AZ
{
Transform result;
result.m_rotation = q;
result.m_scale = Vector3::CreateOne();
result.m_scale = 1.0f;
result.m_translation = p;
return result;
}
AZ_MATH_INLINE Transform Transform::CreateScale(const Vector3& scale)
AZ_MATH_INLINE Transform Transform::CreateScale(const AZ::Vector3& scale)
{
AZ_Warning("Transform", false, "CreateScale is deprecated, please use CreateUniformScale instead.");
Transform result;
result.m_rotation = Quaternion::CreateIdentity();
result.m_scale = scale.GetMaxElement();
result.m_translation = Vector3::CreateZero();
return result;
}
AZ_MATH_INLINE Transform Transform::CreateUniformScale(float scale)
{
Transform result;
result.m_rotation = Quaternion::CreateIdentity();
@@ -76,7 +86,7 @@ namespace AZ
{
Transform result;
result.m_rotation = Quaternion::CreateIdentity();
result.m_scale = Vector3::CreateOne();
result.m_scale = 1.0f;
result.m_translation = translation;
return result;
}
@@ -104,17 +114,17 @@ namespace AZ
AZ_MATH_INLINE Vector3 Transform::GetBasisX() const
{
return m_rotation.TransformVector(Vector3::CreateAxisX(m_scale.GetX()));
return m_rotation.TransformVector(Vector3::CreateAxisX(m_scale));
}
AZ_MATH_INLINE Vector3 Transform::GetBasisY() const
{
return m_rotation.TransformVector(Vector3::CreateAxisY(m_scale.GetY()));
return m_rotation.TransformVector(Vector3::CreateAxisY(m_scale));
}
AZ_MATH_INLINE Vector3 Transform::GetBasisZ() const
{
return m_rotation.TransformVector(Vector3::CreateAxisZ(m_scale.GetZ()));
return m_rotation.TransformVector(Vector3::CreateAxisZ(m_scale));
}
AZ_MATH_INLINE void Transform::GetBasisAndTranslation(Vector3* basisX, Vector3* basisY, Vector3* basisZ, Vector3* pos) const
@@ -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_Warning("Transform", false, "GetScale is deprecated, please use GetUniformScale instead.");
return Vector3(m_scale);
}
AZ_MATH_INLINE float Transform::GetUniformScale() const
{
return m_scale;
}
AZ_MATH_INLINE void Transform::SetScale(const Vector3& scale)
{
AZ_Warning("Transform", false, "SetScale is deprecated, please use SetUniformScale instead.");
m_scale = scale.GetMaxElement();
}
AZ_MATH_INLINE void Transform::SetUniformScale(const float scale)
{
m_scale = scale;
}
AZ_MATH_INLINE Vector3 Transform::ExtractScale()
{
const Vector3 scale = m_scale;
m_scale = Vector3::CreateOne();
AZ_Warning("Transform", false, "ExtractScale is deprecated, please use ExtractUniformScale instead.");
const float scale = m_scale;
m_scale = 1.0f;
return Vector3(scale);
}
AZ_MATH_INLINE float Transform::ExtractUniformScale()
{
const float scale = m_scale;
m_scale = 1.0f;
return scale;
}
AZ_MATH_INLINE void Transform::MultiplyByScale(const Vector3& scale)
AZ_MATH_INLINE void Transform::MultiplyByScale(const AZ::Vector3& scale)
{
AZ_Warning("Transform", false, "MultiplyByScale is deprecated, please use MultiplyByUniformScale instead.");
m_scale *= scale.GetMaxElement();
}
AZ_MATH_INLINE void Transform::MultiplyByUniformScale(float scale)
{
m_scale *= scale;
}
@@ -207,7 +243,7 @@ namespace AZ
// note - need to be careful about how to calculate inverse when there is non-uniform scale
Transform out;
out.m_rotation = m_rotation.GetConjugate();
out.m_scale = m_scale.GetReciprocal();
out.m_scale = 1.0f / m_scale;
out.m_translation = -out.m_scale * (out.m_rotation.TransformVector(m_translation));
return out;
}
@@ -219,27 +255,27 @@ namespace AZ
AZ_MATH_INLINE bool Transform::IsOrthogonal(float tolerance) const
{
return m_scale.IsClose(Vector3::CreateOne(), tolerance);
return AZ::IsClose(m_scale, 1.0f, tolerance);
}
AZ_MATH_INLINE Transform Transform::GetOrthogonalized() const
{
Transform result;
result.m_rotation = m_rotation;
result.m_scale = Vector3::CreateOne();
result.m_scale = 1.0f;
result.m_translation = m_translation;
return result;
}
AZ_MATH_INLINE void Transform::Orthogonalize()
{
*this = GetOrthogonalized();
m_scale = 1.0f;
}
AZ_MATH_INLINE bool Transform::IsClose(const Transform& rhs, float tolerance) const
{
return m_rotation.IsClose(rhs.m_rotation, tolerance)
&& m_scale.IsClose(rhs.m_scale, tolerance)
&& AZ::IsClose(m_scale, rhs.m_scale, tolerance)
&& m_translation.IsClose(rhs.m_translation, tolerance);
}
@@ -268,21 +304,21 @@ namespace AZ
AZ_MATH_INLINE void Transform::SetFromEulerDegrees(const Vector3& eulerDegrees)
{
m_translation = Vector3::CreateZero();
m_scale = Vector3::CreateOne();
m_scale = 1.0f;
m_rotation.SetFromEulerDegrees(eulerDegrees);
}
AZ_MATH_INLINE void Transform::SetFromEulerRadians(const Vector3& eulerRadians)
{
m_translation = Vector3::CreateZero();
m_scale = Vector3::CreateOne();
m_scale = 1.0f;
m_rotation.SetFromEulerRadians(eulerRadians);
}
AZ_MATH_INLINE bool Transform::IsFinite() const
{
return m_rotation.IsFinite()
&& m_scale.IsFinite()
&& IsFiniteFloat(m_scale)
&& m_translation.IsFinite();
}
Code/Framework/AzCore/AzCore/Math/TransformSerializer.cpp
+3 -7
View File
@@ -58,9 +58,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<decltype(scale)>(), inputValue, ScaleTag, context);
@@ -122,10 +120,8 @@ namespace AZ
{
AZ::ScopedContextPath subPathName(context, ScaleTag);
// 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<decltype(scale)>(),
Code/Framework/AzCore/Tests/Math/MathTestData.h
+2 -2
View File
@@ -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[] = {
Code/Framework/AzCore/Tests/Math/ObbTests.cpp
+4 -4
View File
@@ -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)
Code/Framework/AzCore/Tests/Math/TransformPerformanceTests.cpp
+3 -3
View File
@@ -186,7 +186,7 @@ namespace Benchmark
{
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);
}
}
@@ -350,7 +350,7 @@ namespace Benchmark
{
for (auto& testData : m_testDataArray)
{
AZ::Vector3 result = testData.t1.GetScale();
float result = testData.t1.GetUniformScale();
benchmark::DoNotOptimize(result);
}
}
@@ -376,7 +376,7 @@ namespace Benchmark
for (auto& testData : m_testDataArray)
{
AZ::Transform testTransform = testData.t2;
AZ::Vector3 result = testTransform.ExtractScale();
float result = testTransform.ExtractUniformScale();
benchmark::DoNotOptimize(result);
}
}
Code/Framework/AzCore/Tests/Math/TransformTests.cpp
+12 -24
View File
@@ -184,12 +184,12 @@ namespace UnitTest
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 +237,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);
@@ -341,10 +341,10 @@ namespace UnitTest
AZ::Transform unscaledTransform = orthogonalTransform;
unscaledTransform.ExtractScale();
EXPECT_THAT(unscaledTransform.GetScale(), IsClose(AZ::Vector3::CreateOne()));
const AZ::Vector3 scale(2.8f, 0.7f, 1.3f);
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 +353,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<AZ::Vector3>;
@@ -465,10 +452,11 @@ namespace UnitTest
AZ::Transform* deserializedTransform = AZ::Utils::LoadObjectFromBuffer<AZ::Transform>(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);
Code/Framework/AzCore/Tests/ScriptMath.cpp
+12 -12
View File
@@ -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.CreateScale(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.CreateScale(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.CreateScale(3)");
script->Execute("AZTestAssert(t1:GetScale():IsClose(3))");
script->Execute("AZTestAssert(t1:ExtractScale():IsClose(3))");
script->Execute("AZTestAssert(t1:GetScale():IsClose(1))");
script->Execute("t1:MultiplyByScale(2)");
script->Execute("AZTestAssert(t1:GetScale():IsClose(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.CreateScale(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.CreateScale(2)");
script->Execute("AZTestAssert( not t1:IsOrthogonal(0.05))");
////IsClose
Code/Framework/AzCore/Tests/Serialization/Json/TransformSerializerTests.cpp
+3 -3
View File
@@ -44,7 +44,7 @@ namespace JsonSerializationTests
AZStd::shared_ptr<AZ::Transform> CreateFullySetInstance() override
{
return AZStd::make_shared<AZ::Transform>(
AZ::Vector3(1.0f, 2.0f, 3.0f), AZ::Quaternion(0.25f, 0.5f, 0.75f, 1.0f), AZ::Vector3(9.0f));
AZ::Vector3(1.0f, 2.0f, 3.0f), AZ::Quaternion(0.25f, 0.5f, 0.75f, 1.0f), 9.0f);
}
AZStd::string_view GetJsonForFullySetInstance() override
@@ -95,7 +95,7 @@ namespace JsonSerializationTests
AZ::Transform expectedTransform(
AZ::Vector3(2.25f, 3.5f, 4.75f),
AZ::Quaternion(0.25f, 0.5f, 0.75f, 1.0f),
AZ::Vector3(5.5f));
5.5f);
rapidjson::Document json;
json.Parse(R"({ "Translation": [ 2.25, 3.5, 4.75 ], "Rotation": [ 0.25, 0.5, 0.75, 1.0 ], "Scale": 5.5 })");
@@ -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 })");
Code/Framework/AzFramework/AzFramework/Components/TransformComponent.cpp
+19 -19
View File
@@ -447,29 +447,12 @@ namespace AzFramework
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;
}
@@ -527,6 +510,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<AZ::EntityId> TransformComponent::GetChildren()
{
AZStd::vector<AZ::EntityId> children;
Code/Framework/AzFramework/AzFramework/Components/TransformComponent.h
+4 -1
View File
@@ -146,10 +146,13 @@ namespace AzFramework
// Scale Modifiers
void SetLocalScale(const AZ::Vector3& scale) override;
AZ::Vector3 GetLocalScale() override;
AZ::Vector3 GetWorldScale() override;
void SetLocalUniformScale(float scale) override;
float GetLocalUniformScale() override;
float GetWorldUniformScale() override;
// Transform hierarchy
AZStd::vector<AZ::EntityId> GetChildren() override;
AZStd::vector<AZ::EntityId> GetAllDescendants() override;
Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ScaleManipulators.cpp
+1 -3
View File
@@ -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)
Code/Framework/AzToolsFramework/AzToolsFramework/Slice/SliceUtilities.cpp
-2
View File
@@ -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);
}
}
Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponent.cpp
+24 -13
View File
@@ -46,9 +46,9 @@ namespace AzToolsFramework
const AZ::u32 ParentEntityCRC = AZ_CRC("Parent Entity", 0x5b1b276c);
// Decompose a transform into euler angles in degrees, scale (along basis, any shear will be dropped), and translation.
void DecomposeTransform(const AZ::Transform& transform, AZ::Vector3& translation, AZ::Vector3& rotation, AZ::Vector3& scale)
void DecomposeTransform(const AZ::Transform& transform, AZ::Vector3& translation, AZ::Vector3& rotation, float& scale)
{
scale = transform.GetScale();
scale = transform.GetUniformScale();
translation = transform.GetTranslation();
rotation = transform.GetRotation().GetEulerDegrees();
}
@@ -323,7 +323,7 @@ namespace AzToolsFramework
AZ::Transform TransformComponent::GetLocalScaleTM() const
{
return AZ::Transform::CreateScale(m_editorTransform.m_scale);
return AZ::Transform::CreateUniformScale(m_editorTransform.m_scale);
}
const AZ::Transform& TransformComponent::GetLocalTM()
@@ -340,7 +340,8 @@ namespace AzToolsFramework
// given a local transform, update local transform.
void TransformComponent::SetLocalTM(const AZ::Transform& finalTx)
{
AZ::Vector3 tx, rot, scale;
AZ::Vector3 tx, rot;
float scale;
Internal::DecomposeTransform(finalTx, tx, rot, scale);
m_editorTransform.m_translate = tx;
@@ -645,13 +646,13 @@ namespace AzToolsFramework
void TransformComponent::SetLocalScale(const AZ::Vector3& scale)
{
m_editorTransform.m_scale = scale;
m_editorTransform.m_scale = scale.GetMaxElement();
TransformChanged();
}
AZ::Vector3 TransformComponent::GetLocalScale()
{
return m_editorTransform.m_scale;
return AZ::Vector3(m_editorTransform.m_scale);
}
AZ::Vector3 TransformComponent::GetWorldScale()
@@ -659,6 +660,22 @@ namespace AzToolsFramework
return GetWorldTM().GetScale();
}
void TransformComponent::SetLocalUniformScale(float scale)
{
m_editorTransform.m_scale = scale;
TransformChanged();
}
float TransformComponent::GetLocalUniformScale()
{
return m_editorTransform.m_scale;
}
float TransformComponent::GetWorldUniformScale()
{
return GetWorldTM().GetUniformScale();
}
const AZ::Transform& TransformComponent::GetParentWorldTM() const
{
auto parent = GetParentTransformComponent();
@@ -1062,12 +1079,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();
@@ -1214,7 +1225,7 @@ namespace AzToolsFramework
{
AzToolsFramework::ScopedUndoBatch undo("Reset transform values");
m_editorTransform.m_translate = AZ::Vector3::CreateZero();
m_editorTransform.m_scale = AZ::Vector3::CreateOne();
m_editorTransform.m_scale = 1.0f;
m_editorTransform.m_rotate = AZ::Vector3::CreateZero();
OnTransformChanged();
SetDirty();
Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponent.h
+4 -2
View File
@@ -130,10 +130,13 @@ namespace AzToolsFramework
// Scale Modifiers
void SetLocalScale(const AZ::Vector3& scale) 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;
@@ -147,7 +150,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;
Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponentBus.h
+2 -3
View File
@@ -30,7 +30,7 @@ namespace AzToolsFramework
EditorTransform()
{
m_translate = AZ::Vector3::CreateZero();
m_scale = AZ::Vector3::CreateOne();
m_scale = 1.0f;
m_rotate = AZ::Vector3::CreateZero();
m_locked = false;
}
@@ -41,7 +41,7 @@ namespace AzToolsFramework
}
AZ::Vector3 m_translate; //! Translation in engine units (meters)
AZ::Vector3 m_scale;
float m_scale;
AZ::Vector3 m_rotate; //! Rotation in degrees
bool m_locked;
};
@@ -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;
};
Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.cpp
+18 -19
View File
@@ -1472,7 +1472,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);
@@ -1483,7 +1483,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:
@@ -1595,16 +1595,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())
{
@@ -1866,7 +1865,7 @@ namespace AzToolsFramework
CopyOrientationToSelectedEntitiesGroup(QuaternionFromTransformNoScaling(worldFromLocal));
break;
case Mode::Scale:
CopyScaleToSelectedEntitiesIndividualWorld(worldFromLocal.GetScale());
CopyScaleToSelectedEntitiesIndividualWorld(worldFromLocal.GetUniformScale());
break;
case Mode::Translation:
CopyTranslationToSelectedEntitiesGroup(worldFromLocal.GetTranslation());
@@ -1895,7 +1894,7 @@ namespace AzToolsFramework
CopyOrientationToSelectedEntitiesIndividual(QuaternionFromTransformNoScaling(worldFromLocal));
break;
case Mode::Scale:
CopyScaleToSelectedEntitiesIndividualWorld(worldFromLocal.GetScale());
CopyScaleToSelectedEntitiesIndividualWorld(worldFromLocal.GetUniformScale());
break;
case Mode::Translation:
CopyTranslationToSelectedEntitiesIndividual(worldFromLocal.GetTranslation());
@@ -2388,7 +2387,7 @@ namespace AzToolsFramework
ResetOrientationForSelectedEntitiesLocal();
break;
case Mode::Scale:
CopyScaleToSelectedEntitiesIndividualLocal(AZ::Vector3::CreateOne());
CopyScaleToSelectedEntitiesIndividualLocal(1.0f);
break;
case Mode::Translation:
ResetTranslationForSelectedEntitiesLocal();
@@ -2414,7 +2413,7 @@ namespace AzToolsFramework
ResetOrientationForSelectedEntitiesLocal();
break;
case Mode::Scale:
CopyScaleToSelectedEntitiesIndividualWorld(AZ::Vector3::CreateOne());
CopyScaleToSelectedEntitiesIndividualWorld(1.0f);
break;
case Mode::Translation:
// do nothing
@@ -2934,7 +2933,7 @@ namespace AzToolsFramework
}
}
void EditorTransformComponentSelection::CopyScaleToSelectedEntitiesIndividualWorld(const AZ::Vector3& scale)
void EditorTransformComponentSelection::CopyScaleToSelectedEntitiesIndividualWorld(float scale)
{
AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
@@ -2949,7 +2948,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);
@@ -2968,7 +2967,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);
@@ -3014,9 +3013,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);
}
@@ -3661,7 +3660,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);
}
@@ -3714,11 +3713,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)
Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.h
+4 -4
View File
@@ -212,8 +212,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(
@@ -248,7 +248,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).
@@ -316,7 +316,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
Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelectionRequestBus.h
+2 -2
View File
@@ -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;
Code/Framework/GridMate/GridMate/Serialize/CompressionMarshal.cpp
+7 -8
View File
@@ -488,18 +488,17 @@ void TransformCompressor::Marshal(WriteBuffer& wb, const AZ::Transform& value) c
{
AZ::u8 flags = 0;
auto flagsMarker = wb.InsertMarker(flags);
AZ::Matrix3x3 m33 = AZ::Matrix3x3::CreateFromTransform(value);
AZ::Vector3 scale = m33.ExtractScale();
AZ::Quaternion rot = AZ::Quaternion::CreateFromMatrix3x3(m33.GetOrthogonalized());
float scale = value.GetUniformScale();
AZ::Quaternion rot = value.GetRotation();
if (!rot.IsIdentity())
{
flags |= HAS_ROT;
wb.Write(rot, QuatCompMarshaler());
}
if (!scale.IsClose(AZ::Vector3::CreateOne()))
if (!AZ::IsClose(scale, 1.0f))
{
flags |= HAS_SCALE;
wb.Write(scale, Vec3CompMarshaler());
wb.Write(scale, HalfMarshaler());
}
AZ::Vector3 pos = value.GetTranslation();
if (!pos.IsZero())
@@ -527,9 +526,9 @@ void TransformCompressor::Unmarshal(AZ::Transform& value, ReadBuffer& rb) const
}
if (flags & HAS_SCALE)
{
AZ::Vector3 scale;
rb.Read(scale, Vec3CompMarshaler());
xform.MultiplyByScale(scale);
float scale;
rb.Read(scale, HalfMarshaler());
xform.MultiplyByUniformScale(scale);
}
if (flags & HAS_POS)
{
Code/Framework/Tests/TransformComponent.cpp
+44 -66
View File
@@ -24,6 +24,8 @@
#include <AzToolsFramework/Application/ToolsApplication.h>
#include <AzToolsFramework/ToolsComponents/TransformComponent.h>
#include <AZTestShared/Math/MathTestHelpers.h>
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,65 +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 ;
Transform tm;
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
Code/Sandbox/Editor/Objects/SelectionGroup.cpp
-22
View File
@@ -490,28 +490,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()
{
Code/Sandbox/Editor/Objects/SelectionGroup.h
-1
View File
@@ -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.
Code/Sandbox/Editor/TrackView/TrackViewAnimNode.cpp
+9 -9
View File
@@ -1869,7 +1869,7 @@ void CTrackViewAnimNode::SetPos(const Vec3& position)
}
//////////////////////////////////////////////////////////////////////////
void CTrackViewAnimNode::SetScale(const Vec3& scale)
void CTrackViewAnimNode::SetScale(float scale)
{
CTrackViewTrack* track = GetTrackForParameter(AnimParamType::Scale);
@@ -2012,9 +2012,9 @@ void CTrackViewAnimNode::SetPosRotScaleTracksDefaultValues(bool positionAllowed,
}
if (scaleAllowed)
{
AZ::Vector3 scale = AZ::Vector3::CreateOne();
AZ::TransformBus::EventResult(scale, entityId, &AZ::TransformBus::Events::GetWorldScale);
m_animNode->SetScale(time, AZVec3ToLYVec3(scale));
float scale = 1.0f;
AZ::TransformBus::EventResult(scale, entityId, &AZ::TransformBus::Events::GetWorldUniformScale);
m_animNode->SetScale(time, scale);
}
}
}
@@ -2482,11 +2482,11 @@ Quat CTrackViewAnimNode::GetTransformDelegateRotation(const Quat& baseRotation)
//////////////////////////////////////////////////////////////////////////
Vec3 CTrackViewAnimNode::GetTransformDelegateScale(const Vec3& baseScale) const
{
const Vec3 scale = GetScale();
float scale = GetScale();
return Vec3(CheckTrackAnimated(AnimParamType::ScaleX) ? scale.x : baseScale.x,
CheckTrackAnimated(AnimParamType::ScaleY) ? scale.y : baseScale.y,
CheckTrackAnimated(AnimParamType::ScaleZ) ? scale.z : baseScale.z);
return Vec3(CheckTrackAnimated(AnimParamType::ScaleX) ? scale : baseScale.x,
CheckTrackAnimated(AnimParamType::ScaleY) ? scale : baseScale.y,
CheckTrackAnimated(AnimParamType::ScaleZ) ? scale : baseScale.z);
}
//////////////////////////////////////////////////////////////////////////
@@ -2504,7 +2504,7 @@ void CTrackViewAnimNode::SetTransformDelegateRotation(const Quat& rotation)
//////////////////////////////////////////////////////////////////////////
void CTrackViewAnimNode::SetTransformDelegateScale(const Vec3& scale)
{
SetScale(scale);
SetScale(scale.x);
}
bool CTrackViewAnimNode::IsTransformAnimParamTypeDelegated(const AnimParamType animParamType) const
Code/Sandbox/Editor/TrackView/TrackViewAnimNode.h
+2 -2
View File
@@ -182,8 +182,8 @@ public:
// Rotation/Position & Scale
void SetPos(const Vec3& position);
Vec3 GetPos() const { return m_animNode->GetPos(); }
void SetScale(const Vec3& scale);
Vec3 GetScale() const { return m_animNode->GetScale(); }
void SetScale(float scale);
float GetScale() const { return m_animNode->GetScale(); }
void SetRotation(const Quat& rotation);
Quat GetRotation() const { return m_animNode->GetRotate(); }
Quat GetRotation(float time) const { return m_animNode != nullptr ? m_animNode->GetRotate(time) : Quat(0,0,0,0); }
Code/Sandbox/Editor/TrackView/TrackViewSequence.cpp
+3 -3
View File
@@ -825,10 +825,10 @@ void CTrackViewSequence::SyncSelectedTracksToBase()
{
const Vec3 position = pAnimNode->GetPos();
const Quat rotation = pAnimNode->GetRotation();
const Vec3 scale = pAnimNode->GetScale();
const float scale = pAnimNode->GetScale();
AZ::Transform transform = AZ::Transform::CreateIdentity();
transform.SetScale(LYVec3ToAZVec3(scale));
transform.SetUniformScale(scale);
transform.SetRotation(LYQuaternionToAZQuaternion(rotation));
transform.SetTranslation(LYVec3ToAZVec3(position));
@@ -870,7 +870,7 @@ void CTrackViewSequence::SyncSelectedTracksFromBase()
pAnimNode->SetPos(AZVec3ToLYVec3(transform.GetTranslation()));
pAnimNode->SetRotation(AZQuaternionToLYQuaternion(transform.GetRotation()));
pAnimNode->SetScale(AZVec3ToLYVec3(transform.GetScale()));
pAnimNode->SetScale(transform.GetUniformScale());
bNothingWasSynced = false;
}
Code/Tools/SceneAPI/SceneCore/Containers/Utilities/SceneUtilities.cpp
+1 -1
View File
@@ -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())
{
Code/Tools/SceneAPI/SceneUI/RowWidgets/TransformRowHandler.cpp
+7 -5
View File
@@ -13,6 +13,7 @@
#include <AzCore/EBus/EBus.h>
#include <AzToolsFramework/Debug/TraceContext.h>
#include <AzToolsFramework/UI/PropertyEditor/PropertyVectorCtrl.hxx>
#include <AzToolsFramework/UI/PropertyEditor/PropertyDoubleSpinCtrl.hxx>
#include <SceneAPI/SceneUI/RowWidgets/TransformRowHandler.h>
namespace AZ
@@ -58,10 +59,11 @@ namespace AZ
}
else
{
AzToolsFramework::Vector3PropertyHandler handler;
handler.ConsumeAttribute(widget->GetTranslationWidget(), attrib, attrValue, debugName);
handler.ConsumeAttribute(widget->GetRotationWidget(), attrib, attrValue, debugName);
handler.ConsumeAttribute(widget->GetScaleWidget(), attrib, attrValue, debugName);
AzToolsFramework::Vector3PropertyHandler vector3Handler;
vector3Handler.ConsumeAttribute(widget->GetTranslationWidget(), attrib, attrValue, debugName);
vector3Handler.ConsumeAttribute(widget->GetRotationWidget(), attrib, attrValue, debugName);
AzToolsFramework::doublePropertySpinboxHandler spinboxHandler;
spinboxHandler.ConsumeAttribute(widget->GetScaleWidget(), attrib, attrValue, debugName);
}
}
@@ -109,4 +111,4 @@ namespace AZ
} // namespace SceneAPI
} // namespace AZ
#include <RowWidgets/moc_TransformRowHandler.cpp>
#include <RowWidgets/moc_TransformRowHandler.cpp>
Code/Tools/SceneAPI/SceneUI/RowWidgets/TransformRowHandler.h
+1 -1
View File
@@ -60,4 +60,4 @@ namespace AZ
};
} // namespace SceneUI
} // namespace SceneAPI
} // namespace AZ
} // namespace AZ
Code/Tools/SceneAPI/SceneUI/RowWidgets/TransformRowWidget.cpp
+12 -16
View File
@@ -15,6 +15,7 @@
#include <QGridLayout>
#include <SceneAPI/SceneUI/RowWidgets/TransformRowWidget.h>
#include <AzQtComponents/Components/Widgets/VectorInput.h>
#include <AzToolsFramework/UI/PropertyEditor/PropertyDoubleSpinCtrl.hxx>
#include <AzToolsFramework/UI/PropertyEditor/PropertyEditorAPI.h>
#include <AzToolsFramework/UI/PropertyEditor/PropertyRowWidget.hxx>
@@ -47,7 +48,7 @@ namespace AZ
ExpandedTransform::ExpandedTransform()
: m_translation(0, 0, 0)
, m_rotation(0, 0, 0)
, m_scale(1, 1, 1)
, m_scale(1)
{
}
@@ -60,14 +61,14 @@ namespace AZ
{
m_translation = transform.GetTranslation();
m_rotation = transform.GetEulerDegrees();
m_scale = transform.GetScale();
m_scale = transform.GetUniformScale();
}
void ExpandedTransform::GetTransform(AZ::Transform& transform) const
{
transform = Transform::CreateTranslation(m_translation);
transform *= AZ::ConvertEulerDegreesToTransform(m_rotation);
transform.MultiplyByScale(m_scale);
transform.MultiplyByUniformScale(m_scale);
}
const AZ::Vector3& ExpandedTransform::GetTranslation() const
@@ -90,12 +91,12 @@ namespace AZ
m_rotation = rotation;
}
const AZ::Vector3& ExpandedTransform::GetScale() const
const float ExpandedTransform::GetScale() const
{
return m_scale;
}
void ExpandedTransform::SetScale(const AZ::Vector3& scale)
void ExpandedTransform::SetScale(const float scale)
{
m_scale = scale;
}
@@ -131,7 +132,7 @@ namespace AZ
m_rotationWidget->setMaximum(360);
m_rotationWidget->setSuffix(" degrees");
m_scaleWidget = new AzQtComponents::VectorInput(this, 3);
m_scaleWidget = new AzToolsFramework::PropertyDoubleSpinCtrl(this);
m_scaleWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
m_scaleWidget->setMinimum(0);
m_scaleWidget->setMaximum(10000);
@@ -191,13 +192,10 @@ namespace AZ
AzToolsFramework::PropertyEditorGUIMessages::Bus::Broadcast(&AzToolsFramework::PropertyEditorGUIMessages::RequestWrite, this);
});
QObject::connect(m_scaleWidget, &AzQtComponents::VectorInput::valueChanged, this, [this]
QObject::connect(m_scaleWidget, &AzToolsFramework::PropertyDoubleSpinCtrl::valueChanged, this, [this]
{
AzQtComponents::VectorInput* widget = this->GetScaleWidget();
AZ::Vector3 scale;
PopulateVector3(widget, scale);
AzToolsFramework::PropertyDoubleSpinCtrl* widget = this->GetScaleWidget();
float scale = aznumeric_cast<float>(widget->value());
m_transform.SetScale(scale);
AzToolsFramework::PropertyEditorGUIMessages::Bus::Broadcast(&AzToolsFramework::PropertyEditorGUIMessages::RequestWrite, this);
});
@@ -224,9 +222,7 @@ namespace AZ
m_rotationWidget->setValuebyIndex(m_transform.GetRotation().GetY(), 1);
m_rotationWidget->setValuebyIndex(m_transform.GetRotation().GetZ(), 2);
m_scaleWidget->setValuebyIndex(m_transform.GetScale().GetX(), 0);
m_scaleWidget->setValuebyIndex(m_transform.GetScale().GetY(), 1);
m_scaleWidget->setValuebyIndex(m_transform.GetScale().GetZ(), 2);
m_scaleWidget->setValue(m_transform.GetScale());
blockSignals(false);
}
@@ -251,7 +247,7 @@ namespace AZ
return m_rotationWidget;
}
AzQtComponents::VectorInput* TransformRowWidget::GetScaleWidget()
AzToolsFramework::PropertyDoubleSpinCtrl* TransformRowWidget::GetScaleWidget()
{
return m_scaleWidget;
}
Code/Tools/SceneAPI/SceneUI/RowWidgets/TransformRowWidget.h
+11 -5
View File
@@ -21,6 +21,7 @@
#include <AzCore/Math/Uuid.h>
#include <AzCore/Memory/SystemAllocator.h>
#include <SceneAPI/SceneUI/SceneUIConfiguration.h>
#endif
namespace AzQtComponents
@@ -28,6 +29,11 @@ namespace AzQtComponents
class VectorInput;
}
namespace AzToolsFramework
{
class PropertyDoubleSpinCtrl;
}
namespace AZ
{
namespace SceneAPI
@@ -51,14 +57,14 @@ namespace AZ
const AZ::Vector3& GetRotation() const;
void SetRotation(const AZ::Vector3& translation);
const AZ::Vector3& GetScale() const;
void SetScale(const AZ::Vector3& scale);
const float GetScale() const;
void SetScale(const float scale);
private:
AZ_PUSH_DISABLE_DLL_EXPORT_MEMBER_WARNING
AZ::Vector3 m_translation;
AZ::Vector3 m_rotation;
AZ::Vector3 m_scale;
float m_scale;
AZ_POP_DISABLE_DLL_EXPORT_MEMBER_WARNING
};
@@ -78,7 +84,7 @@ namespace AZ
AzQtComponents::VectorInput* GetTranslationWidget();
AzQtComponents::VectorInput* GetRotationWidget();
AzQtComponents::VectorInput* GetScaleWidget();
AzToolsFramework::PropertyDoubleSpinCtrl* GetScaleWidget();
protected:
ExpandedTransform m_transform;
@@ -87,7 +93,7 @@ namespace AZ
AzQtComponents::VectorInput* m_translationWidget;
AzQtComponents::VectorInput* m_rotationWidget;
AzQtComponents::VectorInput* m_scaleWidget;
AzToolsFramework::PropertyDoubleSpinCtrl* m_scaleWidget;
};
} // namespace SceneUI
} // namespace SceneAPI
Code/Tools/SceneAPI/SceneUI/Tests/RowWidgets/TransformRowWidgetTests.cpp
+8 -12
View File
@@ -30,7 +30,7 @@ namespace AZ
Vector3 m_translation = Vector3(10.0f, 20.0f, 30.0f);
Vector3 m_rotation = Vector3(30.0f, 45.0f, 60.0f);
Vector3 m_scale = Vector3(2.0f, 3.0f, 4.0f);
float m_scale = 3.0f;
};
TEST_F(TransformRowWidgetTest, GetTranslation_TranslationInMatrix_TranslationCanBeRetrievedDirectly)
@@ -83,26 +83,22 @@ namespace AZ
TEST_F(TransformRowWidgetTest, GetScale_ScaleInMatrix_ScaleCanBeRetrievedDirectly)
{
m_transform = Transform::CreateScale(m_scale);
m_transform = Transform::CreateUniformScale(m_scale);
m_expanded.SetTransform(m_transform);
const Vector3& returned = m_expanded.GetScale();
EXPECT_NEAR(m_scale.GetX(), returned.GetX(), 0.1f);
EXPECT_NEAR(m_scale.GetY(), returned.GetY(), 0.1f);
EXPECT_NEAR(m_scale.GetZ(), returned.GetZ(), 0.1f);
const float returned = m_expanded.GetScale();
EXPECT_NEAR(m_scale, returned, 0.1f);
}
TEST_F(TransformRowWidgetTest, GetScale_ScaleInMatrix_ScaleCanBeRetrievedFromTransform)
{
m_transform = Transform::CreateScale(m_scale);
m_transform = Transform::CreateUniformScale(m_scale);
m_expanded.SetTransform(m_transform);
Transform rebuild;
m_expanded.GetTransform(rebuild);
Vector3 returned = rebuild.GetScale();
EXPECT_NEAR(m_scale.GetX(), returned.GetX(), 0.1f);
EXPECT_NEAR(m_scale.GetY(), returned.GetY(), 0.1f);
EXPECT_NEAR(m_scale.GetZ(), returned.GetZ(), 0.1f);
float returned = rebuild.GetUniformScale();
EXPECT_NEAR(m_scale, returned, 0.1f);
}
TEST_F(TransformRowWidgetTest, GetTransform_RotateAndTranslateInMatrix_ReconstructedTransformMatchesOriginal)
@@ -121,7 +117,7 @@ namespace AZ
{
Quaternion quaternion = AZ::ConvertEulerDegreesToQuaternion(m_rotation);
m_transform = Transform::CreateFromQuaternionAndTranslation(quaternion, m_translation);
m_transform.MultiplyByScale(m_scale);
m_transform.MultiplyByUniformScale(m_scale);
m_expanded.SetTransform(m_transform);
Transform rebuild;
Gems/Atom/Tools/MaterialEditor/Code/Source/Viewport/MaterialViewportRenderer.cpp
+3 -1
View File
@@ -16,6 +16,7 @@
#include <AzCore/Component/Component.h>
#include <AzFramework/Components/TransformComponent.h>
#include <AzFramework/Components/NonUniformScaleComponent.h>
#include <AzFramework/Entity/GameEntityContextBus.h>
#include <AtomCore/Instance/InstanceDatabase.h>
@@ -178,9 +179,10 @@ namespace MaterialEditor
m_shadowCatcherEntity->CreateComponent(AZ::Render::MeshComponentTypeId);
m_shadowCatcherEntity->CreateComponent(AZ::Render::MaterialComponentTypeId);
m_shadowCatcherEntity->CreateComponent(azrtti_typeid<AzFramework::TransformComponent>());
m_shadowCatcherEntity->CreateComponent(azrtti_typeid<AzFramework::NonUniformScaleComponent>());
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(),
Gems/AtomLyIntegration/CommonFeatures/Code/Source/CoreLights/PolygonLightDelegate.cpp
-1
View File
@@ -50,7 +50,6 @@ namespace AZ
AZStd::vector<Vector2> 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.
AZStd::vector<Vector3> transformedVertices;
transformedVertices.reserve(vertices.size());
Gems/Blast/Code/Tests/BlastFamilyTest.cpp
+1 -1
View File
@@ -137,7 +137,7 @@ namespace Blast
.Times(1)
.WillOnce(Return(false));
AZ::Transform transform = AZ::Transform::CreateScale(AZ::Vector3::CreateOne());
AZ::Transform transform = AZ::Transform::CreateUniformScale(1.0f);
blastFamily->Spawn(transform);
}
Gems/Blast/Code/Tests/Mocks/BlastMocks.h
+3
View File
@@ -669,6 +669,9 @@ namespace Blast
MOCK_METHOD1(SetLocalScale, void(const AZ::Vector3&));
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));
Gems/EMotionFX/Code/EMotionFX/Rendering/Common/RenderUtil.cpp
+1 -1
View File
@@ -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
Gems/GradientSignal/Code/Include/GradientSignal/Util.h
+5 -4
View File
@@ -14,6 +14,7 @@
#include <AzCore/Math/Aabb.h>
#include <AzCore/Math/Vector3.h>
#include <AzCore/Component/EntityId.h>
#include <AzCore/Math/Matrix3x4.h>
#include <AzCore/Math/Transform.h>
#include <LmbrCentral/Shape/ShapeComponentBus.h>
@@ -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());
}
}
Gems/GradientSignal/Code/Source/Components/GradientTransformComponent.cpp
+7 -6
View File
@@ -333,7 +333,7 @@ namespace GradientSignal
AZStd::lock_guard<decltype(m_cacheMutex)> 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)
{
@@ -387,7 +387,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()
@@ -500,10 +500,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
Gems/GradientSignal/Code/Source/Components/GradientTransformComponent.h
+3 -2
View File
@@ -15,6 +15,7 @@
#include <AzCore/Component/Component.h>
#include <AzCore/Component/TickBus.h>
#include <AzCore/Math/Aabb.h>
#include <AzCore/Math/Matrix3x4.h>
#include <AzCore/Math/Transform.h>
#include <AzCore/Math/Vector3.h>
#include <AzCore/std/parallel/atomic.h>
@@ -172,8 +173,8 @@ 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 };
};
} //namespace GradientSignal
} //namespace GradientSignal
Gems/LmbrCentral/Code/Source/Animation/AttachmentComponent.cpp
+2 -2
View File
@@ -242,14 +242,14 @@ namespace LmbrCentral
{
// apply offset in world-space
finalTransform = m_targetEntityTransform * m_targetBoneTransform;
finalTransform.SetScale(AZ::Vector3::CreateOne());
finalTransform.SetUniformScale(1.0f);
finalTransform *= m_targetOffset;
}
else if (m_scaleSource == AttachmentConfiguration::ScaleSource::TargetEntityScale)
{
// apply offset in target-entity-space (ignoring bone scale)
AZ::Transform boneNoScale = m_targetBoneTransform;
boneNoScale.SetScale(AZ::Vector3::CreateOne());
boneNoScale.SetUniformScale(1.0f);
finalTransform = m_targetEntityTransform * boneNoScale * m_targetOffset;
}
Gems/LmbrCentral/Code/Source/Animation/EditorAttachmentComponent.cpp
+1 -1
View File
@@ -124,7 +124,7 @@ namespace LmbrCentral
{
AZ::Transform offset = AZ::ConvertEulerDegreesToTransform(m_rotationOffset);
offset.SetTranslation(m_positionOffset);
offset.MultiplyByScale(m_scaleOffset);
offset.MultiplyByUniformScale(m_scaleOffset.GetMaxElement());
return offset;
}
Gems/LmbrCentral/Code/Source/Scripting/EditorLookAtComponent.cpp
+8 -6
View File
@@ -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());
}
Gems/LmbrCentral/Code/Source/Shape/BoxShape.cpp
+1 -1
View File
@@ -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;
Gems/LmbrCentral/Code/Source/Shape/PolygonPrismShape.cpp
+7 -15
View File
@@ -437,22 +437,18 @@ namespace LmbrCentral
const float height = polygonPrism.GetHeight();
const AZ::Vector3& nonUniformScale = polygonPrism.GetNonUniformScale();
AZ::Transform worldFromLocalUniformScale = worldFromLocal;
const float entityScale = worldFromLocalUniformScale.ExtractScale().GetMaxElement();
worldFromLocalUniformScale *= AZ::Transform::CreateScale(AZ::Vector3(entityScale));
AZ::Aabb aabb = AZ::Aabb::CreateNull();
// check base of prism
for (const AZ::Vector2& vertex : vertexContainer.GetVertices())
{
aabb.AddPoint(worldFromLocalUniformScale.TransformPoint(nonUniformScale * AZ::Vector3(vertex.GetX(), vertex.GetY(), 0.0f)));
aabb.AddPoint(worldFromLocal.TransformPoint(nonUniformScale * AZ::Vector3(vertex.GetX(), vertex.GetY(), 0.0f)));
}
// check top of prism
// set aabb to be height of prism - ensure entire polygon prism shape is enclosed in aabb
for (const AZ::Vector2& vertex : vertexContainer.GetVertices())
{
aabb.AddPoint(worldFromLocalUniformScale.TransformPoint(nonUniformScale * AZ::Vector3(vertex.GetX(), vertex.GetY(), height)));
aabb.AddPoint(worldFromLocal.TransformPoint(nonUniformScale * AZ::Vector3(vertex.GetX(), vertex.GetY(), height)));
}
return aabb;
@@ -468,14 +464,10 @@ namespace LmbrCentral
const AZStd::vector<AZ::Vector2>& vertices = polygonPrism.m_vertexContainer.GetVertices();
const size_t vertexCount = vertices.size();
AZ::Transform worldFromLocalWithUniformScale = worldFromLocal;
const float transformScale = worldFromLocalWithUniformScale.ExtractScale().GetMaxElement();
worldFromLocalWithUniformScale *= AZ::Transform::CreateScale(AZ::Vector3(transformScale));
// 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
const AZ::Vector3 localPoint =
worldFromLocalWithUniformScale.GetInverse().TransformPoint(point) / polygonPrism.GetNonUniformScale();
worldFromLocal.GetInverse().TransformPoint(point) / polygonPrism.GetNonUniformScale();
// ensure the point is not above or below the prism (in its local space)
if (localPoint.GetZ() < 0.0f || localPoint.GetZ() > polygonPrism.GetHeight())
@@ -534,7 +526,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();
@@ -610,9 +602,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);
Gems/LmbrCentral/Code/Source/Shape/ShapeDisplay.h
+2 -7
View File
@@ -42,15 +42,10 @@ namespace LmbrCentral
return;
}
// 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()));
debugDisplay.PushMatrix(worldFromLocalWithUniformScale);
debugDisplay.PushMatrix(worldFromLocal);
drawShape(debugDisplay);
debugDisplay.PopMatrix();
}
} // namespace LmbrCentral
} // namespace LmbrCentral
Gems/LmbrCentral/Code/Source/Shape/TubeShape.cpp
+10 -22
View File
@@ -216,11 +216,7 @@ namespace LmbrCentral
return AZ::Aabb::CreateNull();
}
AZ::Transform worldFromLocalUniformScale = m_currentTransform;
const float maxScale = worldFromLocalUniformScale.ExtractScale().GetMaxElement();
worldFromLocalUniformScale *= AZ::Transform::CreateScale(AZ::Vector3(maxScale));
return CalculateTubeBounds(*this, worldFromLocalUniformScale);
return CalculateTubeBounds(*this, m_currentTransform);
}
void TubeShape::GetTransformAndLocalBounds(AZ::Transform& transform, AZ::Aabb& bounds)
@@ -236,46 +232,38 @@ namespace LmbrCentral
return false;
}
AZ::Transform worldFromLocalNormalized = m_currentTransform;
const AZ::Vector3 scale = AZ::Vector3(worldFromLocalNormalized.ExtractScale().GetMaxElement());
const AZ::Transform localFromWorldNormalized = worldFromLocalNormalized.GetInverse();
const AZ::Vector3 localPoint = localFromWorldNormalized.TransformPoint(point) * scale.GetReciprocal();
const float scale = m_currentTransform.GetUniformScale();
const AZ::Vector3 localPoint = m_currentTransform.GetInverse().TransformPoint(point);
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 AZ::Transform localFromWorldNormalized = worldFromLocalNormalized.GetInverse();
const AZ::Vector3 localPoint = localFromWorldNormalized.TransformPoint(point) * maxScale.GetReciprocal();
const float scale = m_currentTransform.GetUniformScale();
const AZ::Transform localFromWorld = m_currentTransform.GetInverse();
const AZ::Vector3 localPoint = localFromWorld.TransformPoint(point);
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)) * scale, 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));
const auto splineQueryResult = IntersectSpline(transformUniformScale, src, dir, *m_spline);
const auto splineQueryResult = IntersectSpline(m_currentTransform, 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<float>(sqrtf(splineQueryResult.m_distanceSq)) < totalRadius;
}
Gems/LmbrCentral/Code/Tests/BoxShapeTest.cpp
+14 -14
View File
@@ -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,8 +588,8 @@ 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(
@@ -606,8 +606,8 @@ 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(
@@ -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);
Gems/LmbrCentral/Code/Tests/CapsuleShapeTest.cpp
+9 -9
View File
@@ -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;
Gems/LmbrCentral/Code/Tests/CylinderShapeTest.cpp
+7 -7
View File
@@ -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),
Gems/LmbrCentral/Code/Tests/DiskShapeTest.cpp
+1 -1
View File
@@ -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;
Gems/LmbrCentral/Code/Tests/PolygonPrismShapeTest.cpp
+6 -6
View File
@@ -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<AZ::Vector2> 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<AZ::Vector2> 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>(
{
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>(
{
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<AZ::Vector2> vertices =
Gems/LmbrCentral/Code/Tests/QuadShapeTest.cpp
+6 -6
View File
@@ -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;
Gems/LmbrCentral/Code/Tests/SphereShapeTest.cpp
+7 -7
View File
@@ -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;
Gems/LmbrCentral/Code/Tests/TubeShapeTest.cpp
+1 -1
View File
@@ -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);
Gems/Maestro/Code/Source/Cinematics/AnimAZEntityNode.cpp
+3 -3
View File
@@ -189,7 +189,7 @@ Quat CAnimAzEntityNode::GetRotate(float time)
}
//////////////////////////////////////////////////////////////////////////
void CAnimAzEntityNode::SetScale(float time, const Vec3& scale)
void CAnimAzEntityNode::SetScale(float time, float scale)
{
CAnimComponentNode* transformComponent = GetTransformComponentNode();
if (transformComponent)
@@ -198,7 +198,7 @@ void CAnimAzEntityNode::SetScale(float time, const Vec3& scale)
}
}
Vec3 CAnimAzEntityNode::GetScale()
float CAnimAzEntityNode::GetScale()
{
CAnimComponentNode* transformComponent = GetTransformComponentNode();
if (transformComponent)
@@ -206,7 +206,7 @@ Vec3 CAnimAzEntityNode::GetScale()
return transformComponent->GetScale();
}
return Vec3(.0f, .0f, .0f);
return 0.0f;
}
Vec3 CAnimAzEntityNode::GetOffsetPosition(const Vec3& position)
Gems/Maestro/Code/Source/Cinematics/AnimAZEntityNode.h
+2 -2
View File
@@ -57,14 +57,14 @@ public:
void SetPos(float time, const Vec3& pos) override;
void SetRotate(float time, const Quat& quat) override;
void SetScale(float time, const Vec3& scale) override;
void SetScale(float time, float scale) override;
Vec3 GetOffsetPosition(const Vec3& position) override;
Vec3 GetPos() override;
Quat GetRotate() override;
Quat GetRotate(float time) override;
Vec3 GetScale() override;
float GetScale() override;
//////////////////////////////////////////////////////////////////////////
void Serialize(XmlNodeRef& xmlNode, bool bLoading, bool bLoadEmptyTracks);
Gems/Maestro/Code/Source/Cinematics/AnimComponentNode.cpp
+8 -9
View File
@@ -341,10 +341,10 @@ void CAnimComponentNode::ConvertBetweenWorldAndLocalRotation(Quat& rotation, ETr
}
//////////////////////////////////////////////////////////////////////////
void CAnimComponentNode::ConvertBetweenWorldAndLocalScale(Vec3& scale, ETransformSpaceConversionDirection conversionDirection) const
void CAnimComponentNode::ConvertBetweenWorldAndLocalScale(float& scale, ETransformSpaceConversionDirection conversionDirection) const
{
AZ::Transform parentTransform = AZ::Transform::Identity();
AZ::Transform scaleTransform = AZ::Transform::CreateScale(AZ::Vector3(scale.x, scale.y, scale.z));
AZ::Transform scaleTransform = AZ::Transform::CreateUniformScale(scale);
GetParentWorldTransform(parentTransform);
if (conversionDirection == eTransformConverstionDirection_toLocalSpace)
@@ -353,8 +353,7 @@ void CAnimComponentNode::ConvertBetweenWorldAndLocalScale(Vec3& scale, ETransfor
}
scaleTransform = parentTransform * scaleTransform;
AZ::Vector3 vScale = scaleTransform.GetScale();
scale.Set(vScale.GetX(), vScale.GetY(), vScale.GetZ());
scale = scaleTransform.GetUniformScale();
}
//////////////////////////////////////////////////////////////////////////
@@ -457,7 +456,7 @@ Quat CAnimComponentNode::GetRotate()
}
//////////////////////////////////////////////////////////////////////////
void CAnimComponentNode::SetScale(float time, const Vec3& scale)
void CAnimComponentNode::SetScale(float time, float scale)
{
if (m_componentTypeId == AZ::Uuid(AZ::EditorTransformComponentTypeId) || m_componentTypeId == AzFramework::TransformComponent::TYPEINFO_Uuid())
{
@@ -468,7 +467,7 @@ void CAnimComponentNode::SetScale(float time, const Vec3& scale)
{
// Scale is in World space, even if the entity is parented - because Component Entity AZ::Transforms do not correctly set
// CBaseObject parenting, so we convert it to Local space here. This should probably be fixed, but for now, we explicitly change from World to Local space here.
Vec3 localScale(scale);
float localScale = scale;
ConvertBetweenWorldAndLocalScale(localScale, eTransformConverstionDirection_toLocalSpace);
scaleTrack->SetValue(time, localScale, bDefault);
}
@@ -480,15 +479,15 @@ void CAnimComponentNode::SetScale(float time, const Vec3& scale)
}
}
Vec3 CAnimComponentNode::GetScale()
float CAnimComponentNode::GetScale()
{
Maestro::SequenceComponentRequests::AnimatablePropertyAddress animatableAddress(m_componentId, "Scale");
Maestro::SequenceComponentRequests::AnimatedVector3Value scaleValue(AZ::Vector3::CreateZero());
Maestro::SequenceComponentRequests::AnimatedFloatValue scaleValue(0.0f);
Maestro::SequenceComponentRequestBus::Event(m_pSequence->GetSequenceEntityId(), &Maestro::SequenceComponentRequestBus::Events::GetAnimatedPropertyValue, scaleValue, GetParentAzEntityId(), animatableAddress);
// Always return World scale because Component Entity AZ::Transforms do not correctly set
// CBaseObject parenting. This should probably be fixed, but for now, we explicitly change from Local to World space here.
Vec3 worldScale(scaleValue.GetVector3Value());
float worldScale = scaleValue.GetFloatValue();
ConvertBetweenWorldAndLocalScale(worldScale, eTransformConverstionDirection_toWorldSpace);
return worldScale;
Gems/Maestro/Code/Source/Cinematics/AnimComponentNode.h
+3 -3
View File
@@ -71,12 +71,12 @@ public:
void SetPos(float time, const Vec3& pos) override;
void SetRotate(float time, const Quat& quat) override;
void SetScale(float time, const Vec3& scale) override;
void SetScale(float time, float scale) override;
Vec3 GetPos() override;
Quat GetRotate() override;
Quat GetRotate(float time) override;
Vec3 GetScale() override;
float GetScale() override;
void Activate(bool bActivate) override;
//////////////////////////////////////////////////////////////////////////
@@ -128,7 +128,7 @@ private:
void GetParentWorldTransform(AZ::Transform& retTransform) const;
void ConvertBetweenWorldAndLocalPosition(Vec3& position, ETransformSpaceConversionDirection conversionDirection) const;
void ConvertBetweenWorldAndLocalRotation(Quat& rotation, ETransformSpaceConversionDirection conversionDirection) const;
void ConvertBetweenWorldAndLocalScale(Vec3& scale, ETransformSpaceConversionDirection conversionDirection) const;
void ConvertBetweenWorldAndLocalScale(float& scale, ETransformSpaceConversionDirection conversionDirection) const;
// Utility function to query the units for a track and set the track multiplier if needed. Returns true if track multiplier was set.
bool SetTrackMultiplier(IAnimTrack* track) const;
Gems/Maestro/Code/Source/Cinematics/AnimNode.h
+2 -2
View File
@@ -79,12 +79,12 @@ public:
//////////////////////////////////////////////////////////////////////////
void SetPos([[maybe_unused]] float time, [[maybe_unused]] const Vec3& pos) override {};
void SetRotate([[maybe_unused]] float time, [[maybe_unused]] const Quat& quat) override {};
void SetScale([[maybe_unused]] float time, [[maybe_unused]] const Vec3& scale) override {};
void SetScale([[maybe_unused]] float time, [[maybe_unused]] const float scale) override {};
Vec3 GetPos() override { return Vec3(0, 0, 0); };
Quat GetRotate() override { return Quat(0, 0, 0, 0); };
Quat GetRotate(float /*time*/) override { return Quat(0, 0, 0, 0); };
Vec3 GetScale() override { return Vec3(0, 0, 0); };
float GetScale() override { return 0.0f; };
virtual Matrix34 GetReferenceMatrix() const;
Gems/PhysX/Code/Source/RigidBodyComponent.cpp
+4 -13
View File
@@ -203,9 +203,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);
}
}
@@ -244,14 +243,8 @@ namespace PhysX
}
else
{
AZ::Transform transform = m_rigidBody->GetTransform();
// 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, m_rigidBody->GetOrientation());
AZ::TransformBus::Event(GetEntityId(), &AZ::TransformInterface::SetWorldTranslation, m_rigidBody->GetPosition());
}
m_isLastMovementFromKinematicSource = false;
}
@@ -338,8 +331,6 @@ namespace PhysX
m_interpolator = std::make_unique<TransformForwardTimeInterpolator>();
m_interpolator->Reset(transform.GetTranslation(), rotation);
m_initialScale = transform.ExtractScale();
Physics::RigidBodyNotificationBus::Event(GetEntityId(), &Physics::RigidBodyNotificationBus::Events::OnPhysicsEnabled);
Physics::WorldBodyNotificationBus::Event(GetEntityId(), &Physics::WorldBodyNotifications::OnPhysicsEnabled);
}
Gems/PhysX/Code/Source/RigidBodyComponent.h
-1
View File
@@ -159,7 +159,6 @@ namespace PhysX
AzPhysics::RigidBody* m_rigidBody = nullptr;
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
Gems/PhysX/Code/Source/Utils.cpp
+3 -3
View File
@@ -920,9 +920,9 @@ namespace PhysX
AZ::Vector3 GetTransformScale(AZ::EntityId entityId)
{
AZ::Vector3 worldScale = AZ::Vector3::CreateOne();
AZ::TransformBus::EventResult(worldScale, entityId, &AZ::TransformBus::Events::GetWorldScale);
return worldScale;
float worldScale = 1.0f;
AZ::TransformBus::EventResult(worldScale, entityId, &AZ::TransformBus::Events::GetWorldUniformScale);
return AZ::Vector3(worldScale);
}
AZ::Vector3 GetUniformScale(AZ::EntityId entityId)
Gems/PhysX/Code/Tests/ColliderScalingTests.cpp
+6 -6
View File
@@ -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);
Gems/PhysX/Code/Tests/DebugDrawTests.cpp
+7 -7
View File
@@ -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);
Gems/PhysX/Code/Tests/RigidBodyComponentTests.cpp
+4 -4
View File
@@ -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<AzPhysics::SystemInterface>::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);
Gems/PhysX/Code/Tests/ShapeColliderComponentTests.cpp
+5 -7
View File
@@ -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::SetLocalScale, 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());
@@ -435,8 +435,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 +527,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");
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Datum.cpp
+3 -3
View File
@@ -2527,15 +2527,15 @@ namespace ScriptCanvas
{
Data::TransformType copy(source);
AZ::Vector3 pos = copy.GetTranslation();
AZ::Vector3 scale = copy.ExtractScale();
float scale = copy.ExtractUniformScale();
AZ::Vector3 rotation = AZ::ConvertTransformToEulerDegrees(copy);
return AZStd::string::format
( "(Position: X: %f, Y: %f, Z: %f,"
" Rotation: X: %f, Y: %f, Z: %f,"
" Scale: X: %f, Y: %f, Z: %f)"
" Scale: %f)"
, static_cast<float>(pos.GetX()), static_cast<float>(pos.GetY()), static_cast<float>(pos.GetZ())
, static_cast<float>(rotation.GetX()), static_cast<float>(rotation.GetY()), static_cast<float>(rotation.GetZ())
, static_cast<float>(scale.GetX()), static_cast<float>(scale.GetY()), static_cast<float>(scale.GetZ()));
, scale);
}
AZStd::string Datum::ToStringVector2(const AZ::Vector2& source) const
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Entity/Rotate.cpp
+2 -13
View File
@@ -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);
}
}
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Entity/RotateMethod.cpp
+4 -14
View File
@@ -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);
}
}
}
Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Math/TransformNodes.h
+2 -2
View File
@@ -26,9 +26,9 @@ namespace ScriptCanvas
using namespace MathNodeUtilities;
static const char* k_categoryName = "Math/Transform";
AZ_INLINE std::tuple<Vector3Type, TransformType> ExtractScale(TransformType source)
AZ_INLINE std::tuple<NumberType, TransformType> ExtractScale(TransformType source)
{
auto scale(source.ExtractScale());
auto scale(source.ExtractUniformScale());
return std::make_tuple( scale, source );
}
SCRIPT_CANVAS_GENERIC_FUNCTION_MULTI_RESULTS_NODE(ExtractScale, k_categoryName, "{8DFE5247-0950-4CD1-87E6-0CAAD42F1637}", "returns a vector which is the length of the scale components, and a transform with the scale extracted ", "Source", "Scale", "Extracted");
Gems/StartingPointCamera/Code/Source/CameraLookAtBehaviors/RotateCameraLookAt.cpp
+3 -13
View File
@@ -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)