Merge branch 'main' into MultiplayerPipeline

Code/Framework/AzAndroid/java/com/amazon/lumberyard/LumberyardActivity.java

@@ -244,7 +244,7 @@ public class LumberyardActivity extends NativeActivity
         boolean useMainObb = GetBooleanResource("use_main_obb");
         boolean usePatchObb = GetBooleanResource("use_patch_obb");
 
-        if (IsBootstrapInAPK() && (useMainObb || usePatchObb))
+        if (AreAssetsInAPK() && (useMainObb || usePatchObb))
         {
             Log.d(TAG, "Using OBB expansion files for game assets");
 
@@ -421,12 +421,12 @@ public class LumberyardActivity extends NativeActivity
     }
 
     ////////////////////////////////////////////////////////////////
-    private boolean IsBootstrapInAPK()
+    private boolean AreAssetsInAPK()
     {
         try
         {
-            InputStream bootstrap = getAssets().open("bootstrap.cfg", AssetManager.ACCESS_UNKNOWN);
-            bootstrap.close();
+            InputStream engine = getAssets().open("engine.json", AssetManager.ACCESS_UNKNOWN);
+            engine.close();
             return true;
         }
         catch (IOException exception)

Code/Framework/AzCore/AzCore/Android/Utils.cpp

@@ -148,7 +148,7 @@ namespace AZ
                     }
                 }
 
-                AZ_Assert(false, "Failed to locate the bootstrap.cfg path");
+                AZ_Assert(false, "Failed to locate the engine.json path");
                 return nullptr;
             }
 

Code/Framework/AzCore/AzCore/Android/Utils.h

@@ -73,8 +73,8 @@ namespace AZ
             //! \return The pointer position of the relative asset path
             AZ::IO::FixedMaxPath StripApkPrefix(const char* filePath);
 
-            //! Searches application storage and the APK for bootstrap.cfg.  Will return nullptr
-            //! if bootstrap.cfg is not found.
+            //! Searches application storage and the APK for engine.json.  Will return nullptr
+            //! if engine.json is not found.
             const char* FindAssetsDirectory();
 
             //! Calls into Java to show the splash screen on the main UI (Java) thread

Code/Framework/AzCore/AzCore/Component/ComponentApplication.cpp

@@ -462,8 +462,6 @@ namespace AZ
         // for the application root.
         CalculateAppRoot();
 
-        // Merge the bootstrap.cfg file into the Settings Registry as soon as the OSAllocator has been created.
-        SettingsRegistryMergeUtils::MergeSettingsToRegistry_Bootstrap(*m_settingsRegistry);
         SettingsRegistryMergeUtils::MergeSettingsToRegistry_O3deUserRegistry(*m_settingsRegistry, AZ_TRAIT_OS_PLATFORM_CODENAME, {});
         SettingsRegistryMergeUtils::MergeSettingsToRegistry_CommandLine(*m_settingsRegistry, m_commandLine, executeRegDumpCommands);
         SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*m_settingsRegistry);

Code/Framework/AzCore/AzCore/Component/TransformBus.h

@@ -172,78 +172,10 @@ namespace AZ
 
         //! Rotation modifiers
         //! @{
-        //! @deprecated Use SetLocalRotation()
-        //! Sets the entity's rotation in the world.
-        //! The origin of the axes is the entity's position in world space.
-        //! @param eulerAnglesRadians A three-dimensional vector, containing Euler angles in radians, to rotate the entity by.
-        virtual void SetRotation([[maybe_unused]] const AZ::Vector3& eulerAnglesRadians) {}
-
-        //! @deprecated Use SetLocalRotation()
-        //! Sets the entity's rotation around the world's X axis.
-        //! The origin of the axis is the entity's position in world space.
-        //! @param eulerAngleRadians The X coordinate Euler angle in radians to use for the entity's rotation.
-        virtual void SetRotationX([[maybe_unused]] float eulerAngleRadian) {}
-
-        //! @deprecated Use SetLocalRotation()
-        //! Sets the entity's rotation around the world's Y axis.
-        //! The origin of the axis is the entity's position in world space.
-        //! @param eulerAngleRadians The Y coordinate Euler angle in radians to use for the entity's rotation.
-        virtual void SetRotationY([[maybe_unused]] float eulerAngleRadian) {}
-
-        //! @deprecated Use SetLocalRotation()
-        //! Sets the entity's rotation around the world's Z axis.
-        //! The origin of the axis is the entity's position in world space.
-        //! @param eulerAngleRadians The Z coordinate Euler angle in radians to use for the entity's rotation.
-        virtual void SetRotationZ([[maybe_unused]] float eulerAngleRadian) {}
-
-        //! @deprecated Use SetLocalRotationQuaternion()
         //! Sets the entity's rotation in the world in quaternion notation.
         //! The origin of the axes is the entity's position in world space.
         //! @param quaternion A quaternion that represents the rotation to use for the entity.
-        virtual void SetRotationQuaternion([[maybe_unused]] const AZ::Quaternion& quaternion) {}
-
-        //! @deprecated Use RotateAroundLocalX()
-        //! Rotates the entity around the world's X axis.
-        //! The origin of the axis is the entity's position in world space.
-        //! @param eulerAngleRadians The Euler angle in radians by which to rotate the entity around the X axis.
-        virtual void RotateByX([[maybe_unused]] float eulerAngleRadian) {}
-
-        //! @deprecated Use RotateAroundLocalY()
-        //! Rotates the entity around the world's Y axis.
-        //! The origin of the axis is the entity's position in world space.
-        //! @param eulerAngleRadians The Euler angle in radians by which to rotate the entity around the Y axis.
-        virtual void RotateByY([[maybe_unused]] float eulerAngleRadian) {}
-
-        //! @deprecated Use RotateAroundLocalZ()
-        //! Rotates the entity around the world's Z axis.
-        //! The origin of the axis is the entity's position in world space.
-        //! @param eulerAngleRadians The Euler angle in radians by which to rotate the entity around the Z axis.
-        virtual void RotateByZ([[maybe_unused]] float eulerAngleRadian) {}
-
-        //! @deprecated Use GetLocalRotation()
-        //! Gets the entity's rotation in the world in Euler angles rotation in radians.
-        //! @return A three-dimensional vector, containing Euler angles in radians, that represents the entity's rotation.
-        virtual AZ::Vector3 GetRotationEulerRadians() { return AZ::Vector3(FLT_MAX); }
-
-        //! @deprecated Use GetLocalRotationQuaternion()
-        //! Gets the entity's rotation in the world in quaternion format.
-        //! @return A quaternion that represents the entity's rotation in world space.
-        virtual AZ::Quaternion GetRotationQuaternion() { return AZ::Quaternion::CreateZero(); }
-
-        //! @deprecated Use GetLocalRotation()
-        //! Gets the entity's rotation around the world's X axis.
-        //! @return The Euler angle in radians by which the the entity is rotated around the X axis in world space.
-        virtual float GetRotationX() { return FLT_MAX; }
-
-        //! @deprecated Use GetLocalRotation()
-        //! Gets the entity's rotation around the world's Y axis.
-        //! @return The Euler angle in radians by which the the entity is rotated around the Y axis in world space.
-        virtual float GetRotationY() { return FLT_MAX; }
-
-        //! @deprecated Use GetLocalRotation()
-        //! Gets the entity's rotation around the world's Z axis.
-        //! @return The Euler angle in radians by which the the entity is rotated around the Z axis in world space.
-        virtual float GetRotationZ() { return FLT_MAX; }
+        virtual void SetWorldRotationQuaternion([[maybe_unused]] const AZ::Quaternion& quaternion) {}
 
         //! Get angles in radian for each principle axis around which the world transform is
         //! rotated in the order of z-axis and y-axis and then x-axis.
@@ -287,71 +219,28 @@ namespace AZ
 
         //! Scale modifiers
         //! @{
-        //! @deprecated Use SetLocalScale()
-        //! Scales the entity along the world's axes. The origin of the axes is the entity's position in the world.
-        //! @param scale A three-dimensional vector that represents the multipliers with which to scale the entity in world space.
-        virtual void SetScale([[maybe_unused]] const AZ::Vector3& scale) {}
-
-        //! @deprecated Use SetLocalScaleX()
-        //! Scales the entity along the world's X axis. The origin of the axis is the entity's position in the world.
-        //! @param scaleX The multiplier by which to scale the entity along the X axis in world space.
-        virtual void SetScaleX([[maybe_unused]] float scaleX) {}
-
-        //! @deprecated Use SetLocalScaleY()
-        //! Scales the entity along the world's Y axis. The origin of the axis is the entity's position in the world.
-        //! @param scaleY The multiplier by which to scale the entity along the Y axis in world space.
-        virtual void SetScaleY([[maybe_unused]] float scaleY) {}
-
-        //! @deprecated Use SetLocalScaleZ()
-        //! Scales the entity along the world's Z axis. The origin of the axis is the entity's position in the world.
-        //! @param scaleZ The multiplier by which to scale the entity along the Z axis in world space.
-        virtual void SetScaleZ([[maybe_unused]] float scaleZ) {}
-
-        //! @deprecated Use GetLocalScale()
-        //! Gets the scale of the entity in world space.
-        //! @return A three-dimensional vector that represents the scale of the entity in world space.
-        virtual AZ::Vector3 GetScale() { return AZ::Vector3(FLT_MAX); }
-
-        //! @deprecated Use GetLocalScale()
-        //! Gets the amount by which an entity is scaled along the world's X axis.
-        //! @return The amount by which an entity is scaled along the X axis in world space.
-        virtual float GetScaleX() { return FLT_MAX; }
-
-        //! @deprecated Use GetLocalScale()
-        //! Gets the amount by which an entity is scaled along the world's Y axis.
-        //! @return The amount by which an entity is scaled along the Y axis in world space.
-        virtual float GetScaleY() { return FLT_MAX; }
-
-        //! @deprecated Use GetLocalScale()
-        //! Gets the amount by which an entity is scaled along the world's Z axis.
-        //! @return The amount by which an entity is scaled along the Z axis in world space.
-        virtual float GetScaleZ() { return FLT_MAX; }
-
         //! Set local scale of the transform.
-        //! @param scale The new scale to set along three local axes.
+        //! @param scale The new scale to set.
         virtual void SetLocalScale([[maybe_unused]] const AZ::Vector3& scale) {}
 
-        //! Set local scale of the transform on x-axis.
-        //! @param scaleX The new x-axis scale to set.
-        virtual void SetLocalScaleX([[maybe_unused]] float scaleX) {}
-
-        //! Set local scale of the transform on y-axis.
-        //! @param scaleY The new y-axis scale to set.
-        virtual void SetLocalScaleY([[maybe_unused]] float scaleY) {}
-
-        //! Set local scale of the transform on z-axis.
-        //! @param scaleZ The new z-axis scale to set.
-        virtual void SetLocalScaleZ([[maybe_unused]] float scaleZ) {}
-
-        //! Get the scale value on each axis in local space
-        //! @return The scale value of type Vector3 along each axis in local space.
+        //! Get the scale value in local space.
+        //! @return The scale value in local space.
         virtual AZ::Vector3 GetLocalScale() { return AZ::Vector3(FLT_MAX); }
 
-        //! Get the scale value on each axis in world space.
-        //! Note the transform will be skewed when it is rotated and has a parent transform scaled, in which
-        //! case the returned world-scale from this function will be inaccurate.
-        //! @return The scale value of type Vector3 along each axis in world space.
+        //! Get the scale value in world space.
+        //! @return The scale value in world space.
         virtual AZ::Vector3 GetWorldScale() { return AZ::Vector3(FLT_MAX); }
+
+        //! Set the uniform scale value in local space.
+        virtual void SetLocalUniformScale([[maybe_unused]] float scale) {}
+
+        //! Get the uniform scale value in local space.
+        //! @return The uniform scale value in local space.
+        virtual float GetLocalUniformScale() { return FLT_MAX; }
+
+        //! Get the uniform scale value in world space.
+        //! @return The uniform scale value in world space.
+        virtual float GetWorldUniformScale() { return FLT_MAX; }
         //! @}
 
         //! Transform hierarchy

Code/Framework/AzCore/AzCore/Math/Quaternion.cpp

@@ -348,13 +348,20 @@ namespace AZ
         return result.GetW() >= 0.0f ? result : -result;
     }
 
-    const Quaternion Quaternion::CreateFromEulerAnglesDegrees(Vector3& anglesInDegrees)
+    const Quaternion Quaternion::CreateFromEulerAnglesDegrees(const Vector3& anglesInDegrees)
     {
         Quaternion result;
         result.SetFromEulerDegrees(anglesInDegrees);
         return result;
     }
 
+    const Quaternion Quaternion::CreateFromEulerAnglesRadians(const Vector3& anglesInRadians)
+    {
+        Quaternion result;
+        result.SetFromEulerRadians(anglesInRadians);
+        return result;
+    }
+
     Quaternion Quaternion::Slerp(const Quaternion& dest, float t) const
     {
         const float DestDot = Dot(dest);

Code/Framework/AzCore/AzCore/Math/Quaternion.h

@@ -83,8 +83,11 @@ namespace AZ
 
         static Quaternion CreateShortestArc(const Vector3& v1, const Vector3& v2);
 
-        /// Creates a quaternion using rotation in degrees about the axes. First rotated about the X axis, followed by the Y axis, then the Z axis.
-        static const Quaternion CreateFromEulerAnglesDegrees(Vector3& anglesInDegrees);
+        //! Creates a quaternion using rotation in degrees about the axes. First rotated about the X axis, followed by the Y axis, then the Z axis.
+        static const Quaternion CreateFromEulerAnglesDegrees(const Vector3& anglesInDegrees);
+
+        //! Creates a quaternion using rotation in radians about the axes. First rotated about the X axis, followed by the Y axis, then the Z axis.
+        static const Quaternion CreateFromEulerAnglesRadians(const Vector3& anglesInRadians);
 
         //! Stores the vector to an array of 4 floats. The floats need only be 4 byte aligned, 16 byte alignment is not required.
         void StoreToFloat4(float* values) const;

Code/Framework/AzCore/AzCore/Math/Random.h

@@ -126,17 +126,16 @@ namespace AZ
             m_offsets.fill(1); // Halton sequences start at index 1.
             m_increments.fill(1); // By default increment by 1 between each number.
         }
-
-        //! Returns a Halton sequence in an array of N length
-        template<uint32_t N>
-        AZStd::array<AZStd::array<float, Dimensions>, N> GetHaltonSequence()
+        
+        //! Fills a provided container from begin to end with a Halton sequence.
+        //! Entries are expected to be, or implicitly converted to, AZStd::array<float, Dimensions>.
+        template<typename Iterator>
+        void FillHaltonSequence(Iterator begin, Iterator end)
         {
-            AZStd::array<AZStd::array<float, Dimensions>, N> result;
-
             AZStd::array<uint32_t, Dimensions> indices = m_offsets;
 
             // Generator that returns the Halton number for all bases for a single entry.
-            auto f = [&] ()
+            auto f = [&]()
             {
                 AZStd::array<float, Dimensions> item;
                 for (auto d = 0; d < Dimensions; ++d)
@@ -147,12 +146,20 @@ namespace AZ
                 return item;
             };
 
-            AZStd::generate(result.begin(), result.end(), f);
+            AZStd::generate(begin, end, f);
+        }
+        
+        //! Returns a Halton sequence in an array of N length.
+        template<uint32_t N>
+        AZStd::array<AZStd::array<float, Dimensions>, N> GetHaltonSequence()
+        {
+            AZStd::array<AZStd::array<float, Dimensions>, N> result;
+            FillHaltonSequence(result.begin(), result.end());
             return result;
         }
 
         //! Sets the offsets per dimension to start generating a sequence from.
-        //! By default, there is no offset (offset of 0 corresponds to starting at index 1)
+        //! By default, there is no offset (offset of 0 corresponds to starting at index 1).
         void SetOffsets(AZStd::array<uint32_t, Dimensions> offsets)
         {
             m_offsets = offsets;

Code/Framework/AzCore/AzCore/Math/Spline.h

@@ -441,10 +441,10 @@ namespace AZ
         const Transform& worldFromLocal, const Vector3& src, const Vector3& dir, const Spline& spline)
     {
         Transform worldFromLocalNormalized = worldFromLocal;
-        const Vector3 scale = worldFromLocalNormalized.ExtractScale();
+        const float scale = worldFromLocalNormalized.ExtractUniformScale();
         const Transform localFromWorldNormalized = worldFromLocalNormalized.GetInverse();
 
-        const Vector3 localRayOrigin = localFromWorldNormalized.TransformPoint(src) * scale.GetReciprocal();
+        const Vector3 localRayOrigin = localFromWorldNormalized.TransformPoint(src) / scale;
         const Vector3 localRayDirection = localFromWorldNormalized.TransformVector(dir);
         return spline.GetNearestAddressRay(localRayOrigin, localRayDirection);
     }

Code/Framework/AzCore/AzCore/Math/Transform.cpp

@@ -284,10 +284,15 @@ 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("GetUniformScale", &Transform::GetUniformScale)->
+                Method("SetScale", &Transform::SetScale)->
+                Method("SetUniformScale", &Transform::SetUniformScale)->
                 Method("ExtractScale", &Transform::ExtractScale)->
                     Attribute(Script::Attributes::ExcludeFrom, Script::Attributes::ExcludeFlags::All)->
+                Method("ExtractUniformScale", &Transform::ExtractUniformScale)->
+                    Attribute(Script::Attributes::ExcludeFrom, Script::Attributes::ExcludeFlags::All)->
                 Method("MultiplyByScale", &Transform::MultiplyByScale)->
+                Method("MultiplyByUniformScale", &Transform::MultiplyByUniformScale)->
                 Method("GetInverse", &Transform::GetInverse)->
                 Method("Invert", &Transform::Invert)->
                     Attribute(Script::Attributes::ExcludeFrom, Script::Attributes::ExcludeFlags::All)->
@@ -306,6 +311,7 @@ namespace AZ
                 Method("CreateFromMatrix3x3", &Transform::CreateFromMatrix3x3)->
                 Method("CreateFromMatrix3x3AndTranslation", &Transform::CreateFromMatrix3x3AndTranslation)->
                 Method("CreateScale", &Transform::CreateScale)->
+                Method("CreateUniformScale", &Transform::CreateUniformScale)->
                 Method("CreateTranslation", &Transform::CreateTranslation)->
                 Method("ConstructFromValuesNumeric", &Internal::ConstructTransformFromValues);
         }

Code/Framework/AzCore/AzCore/Math/Transform.h

@@ -89,8 +89,11 @@ namespace AZ
 
         static Transform CreateFromMatrix3x4(const Matrix3x4& value);
 
-        //! Sets the matrix to be a scale matrix, translation is set to zero.
-        static Transform CreateScale(const Vector3& scale);
+        //! Sets the transform to apply scale only, no rotation or translation.
+        static Transform CreateScale(const AZ::Vector3& scale);
+
+        //! Sets the transform to apply (uniform) scale only, no rotation or translation.
+        static Transform CreateUniformScale(const float scale);
 
         //! Sets the matrix to be a translation matrix, rotation part is set to identity.
         static Transform CreateTranslation(const Vector3& translation);
@@ -119,13 +122,19 @@ namespace AZ
         const Quaternion& GetRotation() const;
         void SetRotation(const Quaternion& rotation);
 
-        const Vector3& GetScale() const;
+        Vector3 GetScale() const;
+        float GetUniformScale() const;
         void SetScale(const Vector3& v);
+        void SetUniformScale(const float scale);
 
-        //! Sets the transforms scale to a unit value and returns the previous scale value.
+        //! Sets the transform's scale to a unit value and returns the previous scale value.
         Vector3 ExtractScale();
 
-        void MultiplyByScale(const Vector3& scale);
+        //! Sets the transform's scale to a unit value and returns the previous scale value.
+        float ExtractUniformScale();
+
+        void MultiplyByScale(const AZ::Vector3& scale);
+        void MultiplyByUniformScale(float scale);
 
         Transform operator*(const Transform& rhs) const;
         Transform& operator*=(const Transform& rhs);

Code/Framework/AzCore/AzCore/Math/Transform.inl

@@ -65,6 +65,7 @@ namespace AZ
 
     AZ_MATH_INLINE Transform Transform::CreateScale(const Vector3& scale)
     {
+        AZ_WarningOnce("Transform", false, "CreateScale is deprecated, please use CreateUniformScale instead.");
         Transform result;
         result.m_rotation = Quaternion::CreateIdentity();
         result.m_scale = scale;
@@ -72,6 +73,15 @@ namespace AZ
         return result;
     }
 
+    AZ_MATH_INLINE Transform Transform::CreateUniformScale(float scale)
+    {
+        Transform result;
+        result.m_rotation = Quaternion::CreateIdentity();
+        result.m_scale = Vector3(scale);
+        result.m_translation = Vector3::CreateZero();
+        return result;
+    }
+
     AZ_MATH_INLINE Transform Transform::CreateTranslation(const Vector3& translation)
     {
         Transform result;
@@ -150,24 +160,50 @@ namespace AZ
         m_rotation = rotation;
     }
 
-    AZ_MATH_INLINE const Vector3& Transform::GetScale() const
+    AZ_MATH_INLINE Vector3 Transform::GetScale() const
     {
+        AZ_WarningOnce("Transform", false, "GetScale is deprecated, please use GetUniformScale instead.");
         return m_scale;
     }
 
+    AZ_MATH_INLINE float Transform::GetUniformScale() const
+    {
+        return m_scale.GetMaxElement();
+    }
+
     AZ_MATH_INLINE void Transform::SetScale(const Vector3& scale)
     {
+        AZ_WarningOnce("Transform", false, "SetScale is deprecated, please use SetUniformScale instead.");
         m_scale = scale;
     }
 
+    AZ_MATH_INLINE void Transform::SetUniformScale(const float scale)
+    {
+        m_scale = Vector3(scale);
+    }
+
     AZ_MATH_INLINE Vector3 Transform::ExtractScale()
     {
+        AZ_WarningOnce("Transform", false, "ExtractScale is deprecated, please use ExtractUniformScale instead.");
         const Vector3 scale = m_scale;
         m_scale = Vector3::CreateOne();
         return scale;
     }
 
+    AZ_MATH_INLINE float Transform::ExtractUniformScale()
+    {
+        const float scale = m_scale.GetMaxElement();
+        m_scale = Vector3::CreateOne();
+        return scale;
+    }
+
     AZ_MATH_INLINE void Transform::MultiplyByScale(const Vector3& scale)
+    {
+        AZ_WarningOnce("Transform", false, "MultiplyByScale is deprecated, please use MultiplyByUniformScale instead.");
+        m_scale *= scale;
+    }
+
+    AZ_MATH_INLINE void Transform::MultiplyByUniformScale(float scale)
     {
         m_scale *= scale;
     }
@@ -233,7 +269,7 @@ namespace AZ
 
     AZ_MATH_INLINE void Transform::Orthogonalize()
     {
-        *this = GetOrthogonalized();
+        m_scale = Vector3::CreateOne();
     }
 
     AZ_MATH_INLINE bool Transform::IsClose(const Transform& rhs, float tolerance) const

Code/Framework/AzCore/AzCore/Math/TransformSerializer.cpp

@@ -60,7 +60,7 @@ namespace AZ
         {
             // Scale is transitioning to a single uniform scale value, but since it's still internally represented as a Vector3,
             // we need to pick one number to use for load/store operations.
-            float scale = transformInstance->GetScale().GetMaxElement();
+            float scale = transformInstance->GetUniformScale();
 
             JSR::ResultCode loadResult =
                 ContinueLoadingFromJsonObjectField(&scale, azrtti_typeid<decltype(scale)>(), inputValue, ScaleTag, context);
@@ -124,8 +124,8 @@ namespace AZ
 
             // Scale is transitioning to a single uniform scale value, but since it's still internally represented as a Vector3,
             // we need to pick one number to use for load/store operations.
-            float scale = transformInstance->GetScale().GetMaxElement();
-            float defaultScale = defaultTransformInstance ? defaultTransformInstance->GetScale().GetMaxElement() : 0.0f;
+            float scale = transformInstance->GetUniformScale();
+            float defaultScale = defaultTransformInstance ? defaultTransformInstance->GetUniformScale() : 0.0f;
 
             JSR::ResultCode storeResult = ContinueStoringToJsonObjectField(
                 outputValue, ScaleTag, &scale, defaultTransformInstance ? &defaultScale : nullptr, azrtti_typeid<decltype(scale)>(),

Code/Framework/AzCore/AzCore/PlatformId/PlatformDefaults.cpp

@@ -19,7 +19,7 @@ namespace AZ
 {
     inline namespace PlatformDefaults
     {
-        static const char* PlatformNames[PlatformId::NumPlatformIds] = { PlatformPC, PlatformES3, PlatformIOS, PlatformOSX, PlatformProvo, PlatformSalem, PlatformJasper, PlatformServer, PlatformAll, PlatformAllClient };
+        static const char* PlatformNames[PlatformId::NumPlatformIds] = { PlatformPC, PlatformAndroid, PlatformIOS, PlatformMac, PlatformProvo, PlatformSalem, PlatformJasper, PlatformServer, PlatformAll, PlatformAllClient };
 
         const char* PlatformIdToPalFolder(AZ::PlatformId platform)
         {
@@ -31,11 +31,11 @@ namespace AZ
             {
             case AZ::PC:
                 return "PC";
-            case AZ::ES3:
+            case AZ::ANDROID_ID:
                 return "Android";
             case AZ::IOS:
                 return "iOS";
-            case AZ::OSX:
+            case AZ::MAC_ID:
                 return "Mac";
             case AZ::PROVO:
                 return "Provo";
@@ -66,11 +66,11 @@ namespace AZ
             }
             else if (osPlatform == PlatformCodeNameMac)
             {
-                return PlatformOSX;
+                return PlatformMac;
             }
             else if (osPlatform == PlatformCodeNameAndroid)
             {
-                return PlatformES3;
+                return PlatformAndroid;
             }
             else if (osPlatform == PlatformCodeNameiOS)
             {
@@ -207,13 +207,13 @@ namespace AZ
                 platformCodes.emplace_back(PlatformCodeNameWindows);
                 platformCodes.emplace_back(PlatformCodeNameLinux);
                 break;
-            case PlatformId::ES3:
+            case PlatformId::ANDROID_ID:
                 platformCodes.emplace_back(PlatformCodeNameAndroid);
                 break;
             case PlatformId::IOS:
                 platformCodes.emplace_back(PlatformCodeNameiOS);
                 break;
-            case PlatformId::OSX:
+            case PlatformId::MAC_ID:
                 platformCodes.emplace_back(PlatformCodeNameMac);
                 break;
             case PlatformId::PROVO:

Code/Framework/AzCore/AzCore/PlatformId/PlatformDefaults.h

@@ -27,9 +27,9 @@ namespace AZ
     inline namespace PlatformDefaults
     {
         constexpr char PlatformPC[] = "pc";
-        constexpr char PlatformES3[] = "es3";
+        constexpr char PlatformAndroid[] = "android";
         constexpr char PlatformIOS[] = "ios";
-        constexpr char PlatformOSX[] = "osx_gl";
+        constexpr char PlatformMac[] = "mac";
         constexpr char PlatformProvo[] = "provo";
         constexpr char PlatformSalem[] = "salem";
         constexpr char PlatformJasper[] = "jasper";
@@ -54,9 +54,9 @@ namespace AZ
         AZ_ENUM_WITH_UNDERLYING_TYPE(PlatformId, int,
             (Invalid, -1),
             PC,
-            ES3,
+            ANDROID_ID,
             IOS,
-            OSX,
+            MAC_ID,
             PROVO,
             SALEM,
             JASPER,
@@ -73,9 +73,9 @@ namespace AZ
         {
             Platform_NONE = 0x00,
             Platform_PC = 1 << PlatformId::PC,
-            Platform_ES3 = 1 << PlatformId::ES3,
+            Platform_ANDROID = 1 << PlatformId::ANDROID_ID,
             Platform_IOS = 1 << PlatformId::IOS,
-            Platform_OSX = 1 << PlatformId::OSX,
+            Platform_MAC = 1 << PlatformId::MAC_ID,
             Platform_PROVO = 1 << PlatformId::PROVO,
             Platform_SALEM = 1 << PlatformId::SALEM,
             Platform_JASPER = 1 << PlatformId::JASPER,
@@ -87,7 +87,7 @@ namespace AZ
             // A special platform that will always correspond to all non-server platforms, even if new ones are added
             Platform_ALL_CLIENT = 1ULL << 31,
 
-            AllNamedPlatforms = Platform_PC | Platform_ES3 | Platform_IOS | Platform_OSX | Platform_PROVO | Platform_SALEM | Platform_JASPER | Platform_SERVER,
+            AllNamedPlatforms = Platform_PC | Platform_ANDROID | Platform_IOS | Platform_MAC | Platform_PROVO | Platform_SALEM | Platform_JASPER | Platform_SERVER,
         };
 
         AZ_DEFINE_ENUM_BITWISE_OPERATORS(PlatformFlags);

Code/Framework/AzCore/AzCore/PlatformId/PlatformId.cpp

@@ -28,8 +28,8 @@ namespace AZ
             return "Android64";
         case PlatformID::PLATFORM_APPLE_IOS:
             return "iOS";
-        case PlatformID::PLATFORM_APPLE_OSX:
-            return "OSX";
+        case PlatformID::PLATFORM_APPLE_MAC:
+            return "Mac";
 #if defined(AZ_EXPAND_FOR_RESTRICTED_PLATFORM) || defined(AZ_TOOLS_EXPAND_FOR_RESTRICTED_PLATFORMS)
 #define AZ_RESTRICTED_PLATFORM_EXPANSION(CodeName, CODENAME, codename, PrivateName, PRIVATENAME, privatename, PublicName, PUBLICNAME, publicname, PublicAuxName1, PublicAuxName2, PublicAuxName3)\
         case PlatformID::PLATFORM_##PUBLICNAME:\

Code/Framework/AzCore/AzCore/PlatformId/PlatformId.h

@@ -23,7 +23,7 @@ namespace AZ
         PLATFORM_WINDOWS_64,
         PLATFORM_LINUX_64,
         PLATFORM_APPLE_IOS,
-        PLATFORM_APPLE_OSX,
+        PLATFORM_APPLE_MAC,
         PLATFORM_ANDROID_64,    // ARMv8 / 64-bit
         #if defined(AZ_EXPAND_FOR_RESTRICTED_PLATFORM) || defined(AZ_TOOLS_EXPAND_FOR_RESTRICTED_PLATFORMS)
 #define AZ_RESTRICTED_PLATFORM_EXPANSION(CodeName, CODENAME, codename, PrivateName, PRIVATENAME, privatename, PublicName, PUBLICNAME, publicname, PublicAuxName1, PublicAuxName2, PublicAuxName3)\

Code/Framework/AzCore/AzCore/RTTI/AzStdOnDemandReflection.inl

@@ -1020,29 +1020,60 @@ namespace AZ
         }
     };
 
-    /// OnDemand reflection for AZStd::set
+
+    template<class t_Key, class t_Hasher, class t_EqualKey, class t_Allocator>
+    class Iterator_VM<AZStd::unordered_set<t_Key, t_Hasher, t_EqualKey, t_Allocator>>
+    {
+    public:
+        using ContainerType = AZStd::unordered_set<t_Key, t_Hasher, t_EqualKey, t_Allocator>;
+        using IteratorType = typename ContainerType::iterator;
+        Iterator_VM(ContainerType& container)
+            : m_iterator(container.begin())
+            , m_end(container.end())
+        {}
+
+        const t_Key& GetKeyUnchecked() const
+        {
+            return *m_iterator;
+        }
+
+        bool IsNotAtEnd() const
+        {
+            return m_iterator != m_end;
+        }
+
+        t_Key& ModValueUnchecked()
+        {
+            return *m_iterator;
+        }
+
+        void Next()
+        {
+            ++m_iterator;
+        }
+
+    private:
+        IteratorType m_iterator;
+        IteratorType m_end;
+    };
+
+    /// OnDemand reflection for AZStd::unordered_set
     template<class Key, class Hasher, class EqualKey, class Allocator>
     struct OnDemandReflection< AZStd::unordered_set<Key, Hasher, EqualKey, Allocator> >
     {
         using ContainerType = AZStd::unordered_set<Key, Hasher, EqualKey, Allocator>;
         using KeyListType = AZStd::vector<Key, Allocator>;
 
-        static AZ::Outcome<void, void> Erase(ContainerType& thisMap, Key& key)
+        using ValueIteratorType = Iterator_VM<ContainerType>;
+
+        static bool EraseCheck_VM(ContainerType& thisSet, Key& key)
         {
-            const auto result = thisMap.erase(key);
-            if (result)
-            {
-                return AZ::Success();
-            }
-            else
-            {
-                return AZ::Failure();
-            }
+            return thisSet.erase(key) != 0;
         }
 
-        static void Insert(ContainerType& thisSet, Key& key)
+        static ContainerType& ErasePost_VM(ContainerType& thisSet, [[maybe_unused]] Key&)
         {
-            thisSet.insert(key);
+            return thisSet;
         }
 
         static KeyListType GetKeys(ContainerType& thisSet)
@@ -1055,6 +1086,17 @@ namespace AZ
             return keys;
         }
 
+        static ContainerType& Insert(ContainerType& thisSet, Key& key)
+        {
+            thisSet.insert(key);
+            return thisSet;
+        }
+
+        static ValueIteratorType Iterate_VM(ContainerType& thisContainer)
+        {
+            return ValueIteratorType(thisContainer);
+        }
+
         static void Swap(ContainerType& thisSet, ContainerType& otherSet)
         {
             thisSet.swap(otherSet);
@@ -1064,33 +1106,68 @@ namespace AZ
         {
             if (BehaviorContext* behaviorContext = azrtti_cast<BehaviorContext*>(context))
             {
+                BranchOnResultInfo emptyBranchInfo;
+                emptyBranchInfo.m_returnResultInBranches = true;
+                emptyBranchInfo.m_trueToolTip = "The container is empty";
+                emptyBranchInfo.m_falseToolTip = "The container is not empty";
+
                 auto ContainsTransparent = [](const ContainerType& containerType, typename ContainerType::key_type& key)->bool
                 {
                     return containerType.contains(key);
                 };
 
+                ExplicitOverloadInfo explicitOverloadInfo;
                 behaviorContext->Class<ContainerType>()
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
+                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::ListOnly)
                     ->Attribute(AZ::ScriptCanvasAttributes::PrettyName, ScriptCanvasOnDemandReflection::OnDemandPrettyName<ContainerType>::Get(*behaviorContext))
                     ->Attribute(AZ::Script::Attributes::ToolTip, ScriptCanvasOnDemandReflection::OnDemandToolTip<ContainerType>::Get(*behaviorContext))
                     ->Attribute(AZ::Script::Attributes::Category, ScriptCanvasOnDemandReflection::OnDemandCategoryName<ContainerType>::Get(*behaviorContext))
                     ->Attribute(AZ::Script::Attributes::Storage, AZ::Script::Attributes::StorageType::ScriptOwn)
                     ->Method("BucketCount", static_cast<typename ContainerType::size_type(ContainerType::*)() const>(&ContainerType::bucket_count))
-                    ->Method("Erase", &Erase)
-                    ->Method("Empty", [](ContainerType& thisSet)->bool { return thisSet.empty(); })
+                    ->Method("Empty", static_cast<bool(ContainerType::*)() const>(&ContainerType::empty), { { { "Container", "The container to check if it is empty", nullptr, {} } } })
+                        ->Attribute(AZ::ScriptCanvasAttributes::ExplicitOverloadCrc, ExplicitOverloadInfo("Is Empty", "Containers"))
+                        ->Attribute(AZ::ScriptCanvasAttributes::BranchOnResult, emptyBranchInfo)
+                    ->Method("EraseCheck_VM", &EraseCheck_VM)
+                        ->Attribute(AZ::Script::Attributes::TreatAsMemberFunction, AZ::AttributeIsValid::IfPresent)
+                        ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
+                    ->Method("Erase", &ErasePost_VM)
+                        ->Attribute(AZ::Script::Attributes::TreatAsMemberFunction, AZ::AttributeIsValid::IfPresent)
+                        ->Attribute(AZ::ScriptCanvasAttributes::ExplicitOverloadCrc, ExplicitOverloadInfo("Erase", "Containers"))
+                        ->Attribute(AZ::ScriptCanvasAttributes::CheckedOperation, CheckedOperationInfo("EraseCheck_VM", {}, "Out", "Key Not Found", true))
+                        ->Attribute(AZ::ScriptCanvasAttributes::OverloadArgumentGroup, AZ::OverloadArgumentGroupInfo({ "ContainerGroup", "" }, { "ContainerGroup" }))
                     ->Method("contains", ContainsTransparent)
+                        ->Attribute(AZ::ScriptCanvasAttributes::ExplicitOverloadCrc, ExplicitOverloadInfo("Has Key", "Containers"))
                         ->Attribute(AZ::Script::Attributes::TreatAsMemberFunction, AZ::AttributeIsValid::IfPresent)
                     ->Method("Insert", &Insert)
+                        ->Attribute(AZ::Script::Attributes::TreatAsMemberFunction, AZ::AttributeIsValid::IfPresent)
+                        ->Attribute(AZ::ScriptCanvasAttributes::ExplicitOverloadCrc, ExplicitOverloadInfo("Insert", "Containers"))
+                        ->Attribute(AZ::ScriptCanvasAttributes::OverloadArgumentGroup, AZ::OverloadArgumentGroupInfo({ "ContainerGroup", "", "" }, { "ContainerGroup" }))
                     ->Method(k_sizeName, [](ContainerType* thisPtr) { return aznumeric_cast<int>(thisPtr->size()); })
                         ->Attribute(AZ::Script::Attributes::Operator, AZ::Script::Attributes::OperatorType::Length)
                     ->Method("GetKeys", &GetKeys)
                         ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
+                    ->Method("GetSize", [](ContainerType& thisPtr) { return aznumeric_cast<int>(thisPtr.size()); })
+                        ->Attribute(AZ::ScriptCanvasAttributes::ExplicitOverloadCrc, ExplicitOverloadInfo("Get Size", "Containers"))
+                        ->Attribute(AZ::Script::Attributes::TreatAsMemberFunction, AZ::AttributeIsValid::IfPresent)
                     ->Method("Reserve", static_cast<void(ContainerType::*)(typename ContainerType::size_type)>(&ContainerType::reserve))
                     ->Method("Swap", &Swap)
+                    ->Method("Clear", [](ContainerType& thisContainer)->ContainerType& { thisContainer.clear(); return thisContainer; })
+                        ->Attribute(AZ::Script::Attributes::TreatAsMemberFunction, AZ::AttributeIsValid::IfPresent)
+                        ->Attribute(AZ::ScriptCanvasAttributes::ExplicitOverloadCrc, ExplicitOverloadInfo("Clear All Elements", "Containers"))
+                        ->Attribute(AZ::ScriptCanvasAttributes::OverloadArgumentGroup, AZ::OverloadArgumentGroupInfo({ "ContainerGroup" }, { "ContainerGroup" }))
+                    ->Method(k_iteratorConstructorName, &Iterate_VM)
+                        ;
+
+                behaviorContext->Class<ValueIteratorType>()
+                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::ListOnly)
+                    ->Attribute(AZ::Script::Attributes::Storage, AZ::Script::Attributes::StorageType::ScriptOwn)
+                    ->Method(k_iteratorGetKeyName, &ValueIteratorType::GetKeyUnchecked)
+                    ->Method(k_iteratorModValueName, &ValueIteratorType::ModValueUnchecked)
+                    ->Method(k_iteratorIsNotAtEndName, &ValueIteratorType::IsNotAtEnd)
+                    ->Method(k_iteratorNextName, &ValueIteratorType::Next)
                     ;
             }
         }
-
     };
 
     template <>

Code/Framework/AzCore/AzCore/RTTI/BehaviorContext.cpp

@@ -165,7 +165,7 @@ namespace AZ
 
         if (HasResult() != overload->HasResult())
         {
-            AZ_Error("Reflection", false, "Overload failure, all methods must have the same result, or none at all");
+            AZ_Error("Reflection", false, "Overload failure, all methods must have the same result, or none at all: %s", m_name.c_str());
             return false;
         }
 
@@ -176,7 +176,7 @@ namespace AZ
 
             if (!(methodResult->m_typeId == overloadResult->m_typeId && methodResult->m_traits == overloadResult->m_traits))
             {
-                AZ_Error("Reflection", false, "Overload failure, all methods must have the same result, or none at all");
+                AZ_Error("Reflection", false, "Overload failure, all methods must have the same result, or none at all: %s", m_name.c_str());
                 return false;
             }
         }
@@ -575,7 +575,7 @@ namespace AZ
                 }
                 else
                 {
-                    AZ_Error("BehaviorContext", false, "safety check declared for method %s but it was not found in the class");
+                    AZ_Error("BehaviorContext", false, "Method: %s, declared safety check: %s, but it was not found in class: %s", method.m_name.c_str(), m_name.c_str(), checkedOperationInfo.m_safetyCheckName.c_str());
                 }
             }
         }

Code/Framework/AzCore/AzCore/RTTI/BehaviorContextUtilities.cpp

@@ -34,10 +34,17 @@ namespace BehaviorContextUtilitiesCPP
         using argument_type = const BehaviorParameter*;
         using result_type = size_t;
         result_type operator()(const argument_type& value) const 
-        { 
-            result_type result = AZStd::hash<Uuid>()(value->m_typeId);
-            AZStd::hash_combine(result, CleanTraits(value->m_traits));
-            return result;
+        {
+            if (value)
+            { 
+                result_type result = AZStd::hash<Uuid>()(value->m_typeId);
+                AZStd::hash_combine(result, CleanTraits(value->m_traits));
+                return result;
+            }
+            else
+            {
+                return 0;
+            }
         }
     };
 
@@ -45,7 +52,11 @@ namespace BehaviorContextUtilitiesCPP
     {
         bool operator()(const BehaviorParameter* left, const BehaviorParameter* right) const
         {
-            return left->m_typeId == right->m_typeId && CleanTraits(left->m_traits) == CleanTraits(right->m_traits);
+            return (left == nullptr && right == nullptr)
+                || (left != nullptr
+                    && right != nullptr
+                    && left->m_typeId == right->m_typeId
+                    && CleanTraits(left->m_traits) == CleanTraits(right->m_traits));
         }
     };
     
@@ -137,7 +148,7 @@ namespace AZ
         for (size_t argIndex = 0, argSentinel = overload.GetNumArguments(); argIndex < argSentinel; ++argIndex)
         {
             auto overloadedArgIter = variance.m_input.find(argIndex);
-            if (overloadedArgIter != variance.m_input.end())
+            if (overloadedArgIter != variance.m_input.end() && overloadedArgIter->second[overloadIndex])
             {
                 // if this doesn't work try the type name
                 overloadName += ReplaceCppArtifacts(overloadedArgIter->second[overloadIndex]->m_name);
@@ -185,16 +196,24 @@ namespace AZ
             {
                 auto argument = overloads[overloadIndex].first->GetArgument(0);
 
-                const bool isThisPointer
-                    = (argument->m_traits & AZ::BehaviorParameter::Traits::TR_THIS_PTR) != 0
-                    || AZ::FindAttribute(AZ::Script::Attributes::TreatAsMemberFunction, overloads[overloadIndex].first->m_attributes);
+                if (argument)
+                {
+                    const bool isThisPointer
+                        = (argument->m_traits & AZ::BehaviorParameter::Traits::TR_THIS_PTR) != 0
+                        || AZ::FindAttribute(AZ::Script::Attributes::TreatAsMemberFunction, overloads[overloadIndex].first->m_attributes);
 
-                oneArgIsThisPointer = oneArgIsThisPointer || isThisPointer;
+                    oneArgIsThisPointer = oneArgIsThisPointer || isThisPointer;
+                }
 
                 types.insert(argument);
                 stripedArgs.emplace_back(argument);
             }
 
+            if (types.size() == overloads.size())
+            {
+                variance.m_unambiguousInput.insert(0);
+            }
+
             if (types.size() > 1 && (onThis == VariantOnThis::Yes || !oneArgIsThisPointer))
             {
                 variance.m_input.insert(AZStd::make_pair(0, stripedArgs));
@@ -210,11 +229,15 @@ namespace AZ
             for (size_t overloadIndex = 0, overloadSentinel = overloads.size(); overloadIndex < overloadSentinel; ++overloadIndex)
             {
                 auto argument = overloads[overloadIndex].first->GetArgument(argIndex);
-
                 types.insert(argument);
                 stripedArgs.emplace_back(argument);
             }
 
+            if (types.size() == overloads.size())
+            {
+                variance.m_unambiguousInput.insert(0);
+            }
+
             if (types.size() > 1)
             {
                 variance.m_input.insert(AZStd::make_pair(argIndex, stripedArgs));

Code/Framework/AzCore/AzCore/RTTI/BehaviorContextUtilities.h

@@ -27,6 +27,8 @@ namespace AZ
     struct OverloadVariance
     {
         AZStd::unordered_map<size_t, AZStd::vector<const BehaviorParameter*>> m_input;
+        // the indices of inputs that make selection of overload unambiguous
+        AZStd::unordered_set<size_t> m_unambiguousInput;
         AZStd::vector<const BehaviorParameter*> m_output;
     };
 

Code/Framework/AzCore/AzCore/Script/ScriptContext.cpp

@@ -2048,10 +2048,6 @@ LUA_API const Node* lua_getDummyNode()
 
             return true;
         }
-        else
-        {
-            AZ_Warning("Script", false, "Index %d is not a function!", functionIndex);
-        }
 
         return false;
     }
@@ -2078,7 +2074,6 @@ LUA_API const Node* lua_getDummyNode()
         }
         else
         {
-            AZ_Warning("Script", lua_isnil(m_nativeContext, -1), "Name %s exists but is not a function!", functionName);
             lua_pop(m_nativeContext, 1);
         }
 
@@ -5888,7 +5883,6 @@ LUA_API const Node* lua_getDummyNode()
         else
         {
             lua_pop(m_impl->m_lua, 1);
-            AZ_Warning("Script", false, "%s is not a function!", functionName);
         }
         return false;
     }
@@ -5906,7 +5900,6 @@ LUA_API const Node* lua_getDummyNode()
         else
         {
             lua_pop(m_impl->m_lua, 1);
-            AZ_Warning("Script", false, "CacheIndex %d is not a function!", cachedIndex);
         }
         return false;
     }

Code/Framework/AzCore/AzCore/Script/ScriptSystemComponent.cpp

@@ -937,7 +937,7 @@ void ScriptSystemComponent::Reflect(ReflectContext* reflection)
             ->Enum<static_cast<int>(PlatformID::PLATFORM_LINUX_64)>("Linux")
             ->Enum<static_cast<int>(PlatformID::PLATFORM_ANDROID_64)>("Android64")
             ->Enum<static_cast<int>(PlatformID::PLATFORM_APPLE_IOS)>("iOS")
-            ->Enum<static_cast<int>(PlatformID::PLATFORM_APPLE_OSX)>("OSX")
+            ->Enum<static_cast<int>(PlatformID::PLATFORM_APPLE_MAC)>("Mac")
 #if defined(AZ_EXPAND_FOR_RESTRICTED_PLATFORM) || defined(AZ_TOOLS_EXPAND_FOR_RESTRICTED_PLATFORMS)
 #define AZ_RESTRICTED_PLATFORM_EXPANSION(CodeName, CODENAME, codename, PrivateName, PRIVATENAME, privatename, PublicName, PUBLICNAME, publicname, PublicAuxName1, PublicAuxName2, PublicAuxName3)\
             ->Enum<static_cast<int>(PlatformID::PLATFORM_##PUBLICNAME)>(#CodeName)

Code/Framework/AzCore/AzCore/Serialization/Json/JsonDeserializer.cpp

@@ -10,6 +10,7 @@
 *
 */
 
+#include "AzCore/RTTI/TypeInfo.h"
 #include <AzCore/Math/UuidSerializer.h>
 #include <AzCore/RTTI/AttributeReader.h>
 #include <AzCore/Serialization/Json/CastingHelpers.h>
@@ -61,6 +62,13 @@ namespace AZ
 
         if (classData->m_azRtti && classData->m_azRtti->GetGenericTypeId() != typeId)
         {
+            if (((classData->m_azRtti->GetTypeTraits() & (AZ::TypeTraits::is_signed | AZ::TypeTraits::is_unsigned)) != AZ::TypeTraits{0}) &&
+                context.GetSerializeContext()->GetUnderlyingTypeId(typeId) == classData->m_typeId)
+            {
+                // This value is from an enum, where a field has been reflected using ClassBuilder::Field, but the enum
+                // type itself has not been reflected using EnumBuilder. Treat it as an enum.
+                return LoadEnum(object, *classData, value, context);
+            }
             serializer = context.GetRegistrationContext()->GetSerializerForType(classData->m_azRtti->GetGenericTypeId());
             if (serializer)
             {
@@ -77,21 +85,18 @@ namespace AZ
         {
             return LoadEnum(object, *classData, value, context);
         }
-        else if (classData->m_container)
+        if (classData->m_container)
         {
             return context.Report(Tasks::ReadField, Outcomes::Unsupported,
                 "The Json Serializer uses custom serializers to load containers. If this message is encountered "
                 "then a serializer for the target containers is missing, isn't registered or doesn't exist.");
         }
-        else if (value.IsObject())
+        if (value.IsObject())
         {
             return LoadClass(object, *classData, value, context);
         }
-        else
-        {
-            return context.Report(Tasks::ReadField, Outcomes::Unsupported,
-                AZStd::string::format("Reading into targets of type '%s' is not supported.", classData->m_name));
-        }
+        return context.Report(Tasks::ReadField, Outcomes::Unsupported,
+            AZStd::string::format("Reading into targets of type '%s' is not supported.", classData->m_name));
     }
 
     JsonSerializationResult::ResultCode JsonDeserializer::LoadToPointer(void* object, const Uuid& typeId,
@@ -233,8 +238,16 @@ namespace AZ
         AZ::TypeId underlyingTypeId = AZ::TypeId::CreateNull();
         if (!attributeReader.Read<AZ::TypeId>(underlyingTypeId))
         {
-            return context.Report(Tasks::RetrieveInfo, Outcomes::Unknown,
-                "Unable to find underlying type of enum in class data.");
+            // for non-reflected enums, the passed-in classData already represents the enum's underlying type
+            if (context.GetSerializeContext()->GetUnderlyingTypeId(classData.m_typeId) == classData.m_typeId)
+            {
+                underlyingTypeId = classData.m_typeId;
+            }
+            else
+            {
+                return context.Report(Tasks::RetrieveInfo, Outcomes::Unknown,
+                    "Unable to find underlying type of enum in class data.");
+            }
         }
 
         const SerializeContext::ClassData* underlyingClassData = context.GetSerializeContext()->FindClassData(underlyingTypeId);

Code/Framework/AzCore/AzCore/Settings/SettingsRegistryMergeUtils.cpp

@@ -494,13 +494,6 @@ namespace AZ::SettingsRegistryMergeUtils
         return configFileParsed;
     }
 
-    void MergeSettingsToRegistry_Bootstrap(SettingsRegistryInterface& registry)
-    {
-        ConfigParserSettings parserSettings;
-        parserSettings.m_registryRootPointerPath = BootstrapSettingsRootKey;
-        MergeSettingsToRegistry_ConfigFile(registry, "bootstrap.cfg", parserSettings);
-    }
-
     void MergeSettingsToRegistry_AddRuntimeFilePaths(SettingsRegistryInterface& registry)
     {
         using FixedValueString = AZ::SettingsRegistryInterface::FixedValueString;

Code/Framework/AzCore/AzCore/Settings/SettingsRegistryMergeUtils.h

@@ -172,9 +172,6 @@ namespace AZ::SettingsRegistryMergeUtils
     bool MergeSettingsToRegistry_ConfigFile(SettingsRegistryInterface& registry, AZStd::string_view filePath,
         const ConfigParserSettings& configParserSettings);
 
-    //! Loads bootstrap.cfg into the Settings Registry. This file does not support specializations.
-    void MergeSettingsToRegistry_Bootstrap(SettingsRegistryInterface& registry);
-
     //! Extracts file path information from the environment and bootstrap to calculate the various file paths and adds those
     //! to the Settings Registry under the FilePathsRootKey.
     void MergeSettingsToRegistry_AddRuntimeFilePaths(SettingsRegistryInterface& registry);

Code/Framework/AzCore/Platform/Mac/AzCore/PlatformId/PlatformId_Mac.h

@@ -13,5 +13,5 @@
 
 namespace AZ
 {
-    static const PlatformID g_currentPlatform = PlatformID::PLATFORM_APPLE_OSX;
+    static const PlatformID g_currentPlatform = PlatformID::PLATFORM_APPLE_MAC;
 }

Code/Framework/AzCore/Tests/AZTestShared/Utils/Utils.cpp

@@ -31,6 +31,8 @@ namespace UnitTest
     ErrorHandler::ErrorHandler(const char* errorPattern)
         : m_errorCount(0)
         , m_warningCount(0)
+        , m_expectedErrorCount(0)
+        , m_expectedWarningCount(0)
         , m_errorPattern(errorPattern)
     {
         AZ::Debug::TraceMessageBus::Handler::BusConnect();
@@ -51,6 +53,16 @@ namespace UnitTest
         return m_warningCount;
     }
 
+    int ErrorHandler::GetExpectedErrorCount() const
+    {
+        return m_expectedErrorCount;
+    }
+
+    int ErrorHandler::GetExpectedWarningCount() const
+    {
+        return m_expectedWarningCount;
+    }
+
     bool ErrorHandler::SuppressExpectedErrors([[maybe_unused]] const char* window, const char* message)
     {
         return AZStd::string(message).find(m_errorPattern) != AZStd::string::npos;
@@ -61,7 +73,9 @@ namespace UnitTest
         [[maybe_unused]] const char* func, const char* message)
     {
         m_errorCount++;
-        return SuppressExpectedErrors(window, message);
+        bool suppress = SuppressExpectedErrors(window, message);
+        m_expectedErrorCount += suppress;
+        return suppress;
     }
 
     bool ErrorHandler::OnPreWarning(
@@ -69,7 +83,9 @@ namespace UnitTest
         [[maybe_unused]] const char* func, const char* message)
     {
         m_warningCount++;
-        return SuppressExpectedErrors(window, message);
+        bool suppress = SuppressExpectedErrors(window, message);
+        m_expectedWarningCount += suppress;
+        return suppress;
     }
 
     bool ErrorHandler::OnPrintf(const char* window, const char* message)

Code/Framework/AzCore/Tests/AZTestShared/Utils/Utils.h

@@ -30,8 +30,14 @@ namespace UnitTest
     public:
         explicit ErrorHandler(const char* errorPattern);
         ~ErrorHandler();
+        //! Returns the total number of errors encountered (including those which match the expected pattern).
         int GetErrorCount() const;
+        //! Returns the total number of warnings encountered (including those which match the expected pattern).
         int GetWarningCount() const;
+        //! Returns the number of errors encountered which matched the expected pattern.
+        int GetExpectedErrorCount() const;
+        //! Returns the number of warnings encountered which matched the expected pattern.
+        int GetExpectedWarningCount() const;
         bool SuppressExpectedErrors(const char* window, const char* message);
 
         // AZ::Debug::TraceMessageBus
@@ -44,6 +50,8 @@ namespace UnitTest
         AZStd::string m_errorPattern;
         int m_errorCount;
         int m_warningCount;
+        int m_expectedErrorCount;
+        int m_expectedWarningCount;
     };
 }
 

Code/Framework/AzCore/Tests/Math/MathTestData.h

@@ -61,8 +61,8 @@ namespace MathTestData
     };
 
     static const AZ::Transform NonOrthogonalTransforms[] = {
-    AZ::Transform::CreateScale(AZ::Vector3(2.4f, 0.3f, 1.7f)),
-    AZ::Transform::CreateRotationX(2.2f) * AZ::Transform::CreateScale(AZ::Vector3(0.2f, 0.8f, 1.4f))
+        AZ::Transform::CreateUniformScale(2.4f),
+        AZ::Transform::CreateRotationX(2.2f) * AZ::Transform::CreateUniformScale(0.8f)
     };
 
     static const AZ::Transform OrthogonalTransforms[] = {

Code/Framework/AzCore/Tests/Math/ObbTests.cpp

@@ -59,11 +59,11 @@ namespace UnitTest
     TEST(MATH_Obb, TestScaleTransform)
     {
         Obb obb = Obb::CreateFromPositionRotationAndHalfLengths(position, rotation, halfLengths);
-        Vector3 scaleFactors = Vector3(1.0f, 2.0f, 3.0f);
-        Transform transform = Transform::CreateScale(scaleFactors);
+        float scale = 3.0f;
+        Transform transform = Transform::CreateUniformScale(scale);
         obb = transform * obb;
-        EXPECT_THAT(obb.GetPosition(), IsClose(Vector3(1.0f, 4.0f, 9.0f)));
-        EXPECT_THAT(obb.GetHalfLengths(), IsClose(Vector3(0.5f, 1.0f, 1.5f)));
+        EXPECT_THAT(obb.GetPosition(), IsClose(Vector3(3.0f, 6.0f, 9.0f)));
+        EXPECT_THAT(obb.GetHalfLengths(), IsClose(Vector3(1.5f, 1.5f, 1.5f)));
     }
 
     TEST(MATH_Obb, TestSetPosition)

Code/Framework/AzCore/Tests/Math/RandomTests.cpp

@@ -24,7 +24,7 @@ namespace UnitTest
         EXPECT_FLOAT_EQ(5981.0f / 15625.0f, GetHaltonNumber(4321, 5));
     }
 
-    TEST(MATH_Random, HaltonSequence)
+    TEST(MATH_Random, HaltonSequenceStandard)
     {
         HaltonSequence<3> sequence({ 2, 3, 5 });
         auto regularSequence = sequence.GetHaltonSequence<5>();
@@ -48,7 +48,11 @@ namespace UnitTest
         EXPECT_FLOAT_EQ(5.0f / 8.0f, regularSequence[4][0]);
         EXPECT_FLOAT_EQ(7.0f / 9.0f, regularSequence[4][1]);
         EXPECT_FLOAT_EQ(1.0f / 25.0f, regularSequence[4][2]);
-
+    }
+    
+    TEST(MATH_Random, HaltonSequenceOffsets)
+    {
+        HaltonSequence<3> sequence({ 2, 3, 5 });
         sequence.SetOffsets({ 1, 2, 3 });
         auto offsetSequence = sequence.GetHaltonSequence<2>();
 
@@ -59,10 +63,15 @@ namespace UnitTest
         EXPECT_FLOAT_EQ(3.0f / 4.0f, offsetSequence[1][0]);
         EXPECT_FLOAT_EQ(4.0f / 9.0f, offsetSequence[1][1]);
         EXPECT_FLOAT_EQ(1.0f / 25.0f, offsetSequence[1][2]);
-        
+    }
+    
+    TEST(MATH_Random, HaltonSequenceIncrements)
+    {
+        HaltonSequence<3> sequence({ 2, 3, 5 });
+        sequence.SetOffsets({ 1, 2, 3 });
         sequence.SetIncrements({ 1, 2, 3 });
         auto incrementedSequence = sequence.GetHaltonSequence<2>();
-        
+
         EXPECT_FLOAT_EQ(1.0f / 4.0f, incrementedSequence[0][0]);
         EXPECT_FLOAT_EQ(1.0f / 9.0f, incrementedSequence[0][1]);
         EXPECT_FLOAT_EQ(4.0f / 5.0f, incrementedSequence[0][2]);
@@ -71,4 +80,35 @@ namespace UnitTest
         EXPECT_FLOAT_EQ(7.0f / 9.0f, incrementedSequence[1][1]);
         EXPECT_FLOAT_EQ(11.0f / 25.0f, incrementedSequence[1][2]);
     }
+    
+    TEST(MATH_Random, FillHaltonSequence)
+    {
+        HaltonSequence<3> sequence({ 2, 3, 5 });
+        auto regularSequence = sequence.GetHaltonSequence<5>();
+
+        struct Point
+        {
+            Point() = default;
+            Point(AZStd::array<float, 3> arr)
+                :x(arr[0])
+                ,y(arr[1])
+                ,z(arr[2])
+            {}
+
+            float x = 0.0f;
+            float y = 0.0f;
+            float z = 0.0f;
+        };
+
+        AZStd::array<Point, 5> ownedContainer;
+        sequence.FillHaltonSequence(ownedContainer.begin(), ownedContainer.end());
+
+        for (size_t i = 0; i < regularSequence.size(); ++i)
+        {
+            EXPECT_FLOAT_EQ(regularSequence[i][0], ownedContainer[i].x);
+            EXPECT_FLOAT_EQ(regularSequence[i][1], ownedContainer[i].y);
+            EXPECT_FLOAT_EQ(regularSequence[i][2], ownedContainer[i].z);
+        }
+    }
+
 }

Code/Framework/AzCore/Tests/Math/TransformPerformanceTests.cpp

@@ -180,13 +180,13 @@ namespace Benchmark
         }
     }
 
-    BENCHMARK_F(BM_MathTransform, CreateScale)(benchmark::State& state)
+    BENCHMARK_F(BM_MathTransform, CreateUniformScale)(benchmark::State& state)
     {
         for (auto _ : state)
         {
             for (auto& testData : m_testDataArray)
             {
-                AZ::Transform result = AZ::Transform::CreateScale(testData.v3);
+                AZ::Transform result = AZ::Transform::CreateUniformScale(testData.value[0]);
                 benchmark::DoNotOptimize(result);
             }
         }
@@ -344,39 +344,39 @@ namespace Benchmark
         }
     }
 
-    BENCHMARK_F(BM_MathTransform, GetScale)(benchmark::State& state)
+    BENCHMARK_F(BM_MathTransform, GetUniformScale)(benchmark::State& state)
     {
         for (auto _ : state)
         {
             for (auto& testData : m_testDataArray)
             {
-                AZ::Vector3 result = testData.t1.GetScale();
+                float result = testData.t1.GetUniformScale();
                 benchmark::DoNotOptimize(result);
             }
         }
     }
 
-    BENCHMARK_F(BM_MathTransform, SetScale)(benchmark::State& state)
+    BENCHMARK_F(BM_MathTransform, SetUniformScale)(benchmark::State& state)
     {
         for (auto _ : state)
         {
             for (auto& testData : m_testDataArray)
             {
                 AZ::Transform testTransform = testData.t2;
-                testTransform.SetScale(testData.v3);
+                testTransform.SetUniformScale(testData.value[0]);
                 benchmark::DoNotOptimize(testTransform);
             }
         }
     }
 
-    BENCHMARK_F(BM_MathTransform, ExtractScale)(benchmark::State& state)
+    BENCHMARK_F(BM_MathTransform, ExtractUniformScale)(benchmark::State& state)
     {
         for (auto _ : state)
         {
             for (auto& testData : m_testDataArray)
             {
                 AZ::Transform testTransform = testData.t2;
-                AZ::Vector3 result = testTransform.ExtractScale();
+                float result = testTransform.ExtractUniformScale();
                 benchmark::DoNotOptimize(result);
             }
         }

Code/Framework/AzCore/Tests/Math/TransformTests.cpp

@@ -159,37 +159,14 @@ namespace UnitTest
 
     INSTANTIATE_TEST_CASE_P(MATH_Transform, TransformCreateFromQuaternionFixture, ::testing::ValuesIn(MathTestData::UnitQuaternions));
 
-    using TransformCreateFromMatrix3x3Fixture = ::testing::TestWithParam<AZ::Matrix3x3>;
-
-    TEST_P(TransformCreateFromMatrix3x3Fixture, CreateFromMatrix3x3)
+    TEST(MATH_Transform, CreateUniformScale)
     {
-        const AZ::Matrix3x3 matrix3x3 = GetParam();
-        const AZ::Transform transform = AZ::Transform::CreateFromMatrix3x3(matrix3x3);
-        EXPECT_THAT(transform.GetTranslation(), IsClose(AZ::Vector3::CreateZero()));
-        const AZ::Vector3 vector(2.3f, -0.6, 1.8f);
-        EXPECT_THAT(transform.TransformPoint(vector), IsClose(matrix3x3 * vector));
-    }
-
-    TEST_P(TransformCreateFromMatrix3x3Fixture, CreateFromMatrix3x3AndTranslation)
-    {
-        const AZ::Matrix3x3 matrix3x3 = GetParam();
-        const AZ::Vector3 translation(-2.6f, 1.7f, 0.8f);
-        const AZ::Transform transform = AZ::Transform::CreateFromMatrix3x3AndTranslation(matrix3x3, translation);
-        EXPECT_THAT(transform.GetTranslation(), IsClose(translation));
-        const AZ::Vector3 vector(2.3f, -0.6, 1.8f);
-        EXPECT_THAT(transform.TransformPoint(vector), IsClose(matrix3x3 * vector + translation));
-    }
-
-    INSTANTIATE_TEST_CASE_P(MATH_Transform, TransformCreateFromMatrix3x3Fixture, ::testing::ValuesIn(MathTestData::Matrix3x3s));
-
-    TEST(MATH_Transform, CreateScale)
-    {
-        const AZ::Vector3 scale(1.7f, 0.3f, 2.4f);
-        const AZ::Transform transform = AZ::Transform::CreateScale(scale);
+        const float scale = 1.7f;
+        const AZ::Transform transform = AZ::Transform::CreateUniformScale(scale);
         const AZ::Vector3 vector(0.2f, -1.6f, 0.4f);
         EXPECT_THAT(transform.GetTranslation(), IsClose(AZ::Vector3::CreateZero()));
         const AZ::Vector3 transformedVector = transform.TransformPoint(vector);
-        const AZ::Vector3 expected(0.34f, -0.48f, 0.96f);
+        const AZ::Vector3 expected(0.34f, -2.72f, 0.68f);
         EXPECT_THAT(transformedVector, IsClose(expected));
     }
 
@@ -237,10 +214,10 @@ namespace UnitTest
     TEST(MATH_Transform, MultiplyByTransform)
     {
         const AZ::Transform transform1 = AZ::Transform::CreateRotationY(0.3f);
-        const AZ::Transform transform2 = AZ::Transform::CreateScale(AZ::Vector3(1.3f, 1.5f, 0.4f));
+        const AZ::Transform transform2 = AZ::Transform::CreateUniformScale(1.3f);
         const AZ::Transform transform3 = AZ::Transform::CreateFromQuaternionAndTranslation(
             AZ::Quaternion(0.42f, 0.46f, -0.66f, 0.42f), AZ::Vector3(2.8f, -3.7f, 1.6f));
-        const AZ::Transform transform4 = AZ::Transform::CreateRotationX(-0.7f) * AZ::Transform::CreateScale(AZ::Vector3(0.6f, 1.3f, 0.7f));
+        const AZ::Transform transform4 = AZ::Transform::CreateRotationX(-0.7f) * AZ::Transform::CreateUniformScale(0.6f);
         AZ::Transform transform5 = transform1;
         transform5 *= transform4;
         const AZ::Vector3 vector(1.9f, 2.3f, 0.2f);
@@ -254,14 +231,14 @@ namespace UnitTest
     TEST(MATH_Transform, TranslationCorrectInTransformHierarchy)
     {
         AZ::Transform parent = AZ::Transform::CreateRotationZ(AZ::DegToRad(45.0f));
-        parent.SetScale(AZ::Vector3(3.0f, 2.0f, 1.0f));
+        parent.SetUniformScale(3.0f);
         parent.SetTranslation(AZ::Vector3(0.2f, 0.3f, 0.4f));
         AZ::Transform child = AZ::Transform::CreateRotationZ(AZ::DegToRad(90.0f));
         child.SetTranslation(AZ::Vector3(0.5f, 0.6f, 0.7f));
         const AZ::Transform overallTransform = parent * child;
         const AZ::Vector3 overallTranslation = overallTransform.GetTranslation();
-        const AZ::Vector3 expectedTranslation(0.412132f, 2.20919f, 1.1f);
-        EXPECT_THAT(overallTranslation, IsClose(AZ::Vector3(0.412132f, 2.20919f, 1.1f)));
+        const AZ::Vector3 expectedTranslation(-0.012132f, 2.633452f, 2.5f);
+        EXPECT_THAT(overallTranslation, IsClose(expectedTranslation));
     }
 
     TEST(MATH_Transform, TransformPointVector3)
@@ -337,14 +314,14 @@ namespace UnitTest
     TEST_P(TransformScaleFixture, Scale)
     {
         const AZ::Transform orthogonalTransform = GetParam();
-        EXPECT_THAT(orthogonalTransform.GetScale(), IsClose(AZ::Vector3::CreateOne()));
+        EXPECT_NEAR(orthogonalTransform.GetUniformScale(), 1.0f, AZ::Constants::Tolerance);
         AZ::Transform unscaledTransform = orthogonalTransform;
-        unscaledTransform.ExtractScale();
-        EXPECT_THAT(unscaledTransform.GetScale(), IsClose(AZ::Vector3::CreateOne()));
-        const AZ::Vector3 scale(2.8f, 0.7f, 1.3f);
+        unscaledTransform.ExtractUniformScale();
+        EXPECT_NEAR(unscaledTransform.GetUniformScale(), 1.0f, AZ::Constants::Tolerance);
+        const float scale = 2.8f;
         AZ::Transform scaledTransform = orthogonalTransform;
-        scaledTransform.MultiplyByScale(scale);
-        EXPECT_THAT(scaledTransform.GetScale(), IsClose(scale));
+        scaledTransform.MultiplyByUniformScale(scale);
+        EXPECT_NEAR(scaledTransform.GetUniformScale(), scale, AZ::Constants::Tolerance);
     }
 
     INSTANTIATE_TEST_CASE_P(MATH_Transform, TransformScaleFixture, ::testing::ValuesIn(MathTestData::OrthogonalTransforms));
@@ -353,24 +330,11 @@ namespace UnitTest
     {
         EXPECT_TRUE(AZ::Transform::CreateIdentity().IsOrthogonal());
         EXPECT_TRUE(AZ::Transform::CreateRotationZ(0.3f).IsOrthogonal());
-        EXPECT_FALSE(AZ::Transform::CreateScale(AZ::Vector3(0.8f, 0.3f, 1.2f)).IsOrthogonal());
+        EXPECT_FALSE(AZ::Transform::CreateUniformScale(0.8f).IsOrthogonal());
         EXPECT_TRUE(AZ::Transform::CreateFromQuaternion(AZ::Quaternion(-0.52f, -0.08f, 0.56f, 0.64f)).IsOrthogonal());
         AZ::Transform transform;
         transform.SetFromEulerRadians(AZ::Vector3(0.2f, 0.4f, 0.1f));
         EXPECT_TRUE(transform.IsOrthogonal());
-
-        // want to test each possible way the transform could fail to be orthogonal, which we can do by testing for one
-        // axis, then using a rotation which cycles the axes
-        const AZ::Transform axisCycle = AZ::Transform::CreateFromQuaternion(AZ::Quaternion(0.5f, 0.5f, 0.5f, 0.5f));
-
-        // a transform which is normalized in 2 axes, but not the third
-        AZ::Transform nonOrthogonalTransform1 = AZ::Transform::CreateScale(AZ::Vector3(1.0f, 1.0f, 2.0f));
-
-        for (int i = 0; i < 3; i++)
-        {
-            EXPECT_FALSE(nonOrthogonalTransform1.IsOrthogonal());
-            nonOrthogonalTransform1 = axisCycle * nonOrthogonalTransform1;
-        }
     }
 
     using TransformSetFromEulerDegreesFixture = ::testing::TestWithParam<AZ::Vector3>;
@@ -459,16 +423,17 @@ namespace UnitTest
     {
         const char* objectStreamBuffer =
             R"DELIMITER(<ObjectStream version="3">
-            <Class name="Transform" field="m_data" value="0.79429845 0.8545947 -0.94273965 -0.05367075 0.3899708 0.30828915 1.0097652 -0.31084164 0.56899188 513.7845459 492.5420837 32.0000000" type="{5D9958E9-9F1E-4985-B532-FFFDE75FEDFD}"/>
+            <Class name="Transform" field="m_data" value="0.79429845 0.8545947 -0.94273965 -0.1610121 1.1699124 0.92486745 1.2622065 -0.3885522 0.71123985 513.7845459 492.5420837 32.0000000" type="{5D9958E9-9F1E-4985-B532-FFFDE75FEDFD}"/>
             </ObjectStream>)DELIMITER";
 
         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

@@ -1275,10 +1275,10 @@ namespace UnitTest
         script->Execute("AZTestAssert(t1:TransformVector(Vector3(1, 0, 0)):IsClose(Vector3(1, 0, 0)))");
         script->Execute("AZTestAssert(t1:TransformVector(Vector3(0, 1, 0)):IsClose(Vector3(0, 0.866, 0.5)))");
         script->Execute("AZTestAssert(t1:TransformVector(Vector3(0, 0, 1)):IsClose(Vector3(0, -0.5, 0.866)))");
-        script->Execute("t1 = Transform.CreateScale(Vector3(1, 2, 3))");
-        script->Execute("AZTestAssert(t1:TransformVector(Vector3(1, 0, 0)):IsClose(Vector3(1, 0, 0)))");
+        script->Execute("t1 = Transform.CreateUniformScale(2)");
+        script->Execute("AZTestAssert(t1:TransformVector(Vector3(1, 0, 0)):IsClose(Vector3(2, 0, 0)))");
         script->Execute("AZTestAssert(t1:TransformVector(Vector3(0, 1, 0)):IsClose(Vector3(0, 2, 0)))");
-        script->Execute("AZTestAssert(t1:TransformVector(Vector3(0, 0, 1)):IsClose(Vector3(0, 0, 3)))");
+        script->Execute("AZTestAssert(t1:TransformVector(Vector3(0, 0, 1)):IsClose(Vector3(0, 0, 2)))");
         script->Execute("t1 = Transform.CreateTranslation(Vector3(1, 2, 3))");
         script->Execute("AZTestAssert(t1:TransformVector(Vector3(1, 0, 0)):IsClose(Vector3(1, 0, 0)))");
         script->Execute("AZTestAssert(t1:TransformVector(Vector3(0, 1, 0)):IsClose(Vector3(0, 1, 0)))");
@@ -1341,19 +1341,19 @@ namespace UnitTest
         script->Execute("AZTestAssert(t3:GetTranslation():IsClose(Vector3(-5.90, 25.415, 19.645), 0.001))");
 
         ////test inverse, should handle non-orthogonal matrices
-        script->Execute("t1 = Transform.CreateRotationX(1) * Transform.CreateScale(Vector3(1, 2, 3))");
+        script->Execute("t1 = Transform.CreateRotationX(1) * Transform.CreateUniformScale(2)");
         script->Execute("AZTestAssert((t1*t1:GetInverse()):IsClose(Transform.CreateIdentity()))");
 
         ////scale access
-        script->Execute("t1 = Transform.CreateRotationX(Math.DegToRad(40)) * Transform.CreateScale(Vector3(2, 3, 4))");
-        script->Execute("AZTestAssert(t1:GetScale():IsClose(Vector3(2, 3, 4)))");
-        script->Execute("AZTestAssert(t1:ExtractScale():IsClose(Vector3(2, 3, 4)))");
-        script->Execute("AZTestAssert(t1:GetScale():IsClose(Vector3.CreateOne()))");
-        script->Execute("t1:MultiplyByScale(Vector3(3, 4, 5))");
-        script->Execute("AZTestAssert(t1:GetScale():IsClose(Vector3(3, 4, 5)))");
+        script->Execute("t1 = Transform.CreateRotationX(Math.DegToRad(40)) * Transform.CreateUniformScale(3)");
+        script->Execute("AZTestAssertFloatClose(t1:GetUniformScale(), 3)");
+        script->Execute("AZTestAssertFloatClose(t1:ExtractUniformScale(), 3)");
+        script->Execute("AZTestAssertFloatClose(t1:GetUniformScale(), 1)");
+        script->Execute("t1:MultiplyByUniformScale(2)");
+        script->Execute("AZTestAssertFloatClose(t1:GetUniformScale(), 2)");
 
         ////orthogonalize
-        script->Execute("t1 = Transform.CreateRotationX(Math.DegToRad(30)) * Transform.CreateScale(Vector3(2, 3, 4))");
+        script->Execute("t1 = Transform.CreateRotationX(Math.DegToRad(30)) * Transform.CreateUniformScale(3)");
         script->Execute("t1:SetTranslation(Vector3(1,2,3))");
         script->Execute("t2 = t1:GetOrthogonalized()");
         script->Execute("AZTestAssertFloatClose(t2:GetBasisX():GetLength(), 1)");
@@ -1372,7 +1372,7 @@ namespace UnitTest
         script->Execute("t1 = Transform.CreateRotationX(Math.DegToRad(30))");
         script->Execute("t1:SetTranslation(Vector3(1, 2, 3))");
         script->Execute("AZTestAssert(t1:IsOrthogonal(0.05))");
-        script->Execute("t1 = Transform.CreateRotationX(Math.DegToRad(30)) * Transform.CreateScale(Vector3(2, 3, 4))");
+        script->Execute("t1 = Transform.CreateRotationX(Math.DegToRad(30)) * Transform.CreateUniformScale(2)");
         script->Execute("AZTestAssert( not t1:IsOrthogonal(0.05))");
 
         ////IsClose

Code/Framework/AzCore/Tests/Serialization/Json/TestCases.h

@@ -21,7 +21,7 @@ namespace JsonSerializationTests
 {
     using JsonSerializationTestCases = ::testing::Types<
         // Structures
-        SimpleClass, SimpleInheritence, MultipleInheritence, SimpleNested, SimpleEnumWrapper,
+        SimpleClass, SimpleInheritence, MultipleInheritence, SimpleNested, SimpleEnumWrapper, NonReflectedEnumWrapper,
         // Pointers
         SimpleNullPointer, SimpleAssignedPointer, ComplexAssignedPointer, ComplexNullInheritedPointer,
         ComplexAssignedDifferentInheritedPointer, ComplexAssignedSameInheritedPointer,

Code/Framework/AzCore/Tests/Serialization/Json/TestCases_Classes.cpp

@@ -373,6 +373,57 @@ namespace JsonSerializationTests
         return MakeInstanceWithoutDefaults(AZStd::move(instance), json);
     }
 
+    // NonReflectedEnumWrapper
+    bool NonReflectedEnumWrapper::Equals(const NonReflectedEnumWrapper& rhs, bool fullReflection) const
+    {
+        return !fullReflection || (m_enumClass == rhs.m_enumClass && m_rawEnum== rhs.m_rawEnum);
+    }
+
+    void NonReflectedEnumWrapper::Reflect(AZStd::unique_ptr<AZ::SerializeContext>& context, bool fullReflection)
+    {
+        if (fullReflection)
+        {
+            // Note that the enums are not reflected using context->Enum<>
+
+            context->Class<NonReflectedEnumWrapper>()
+                ->Field("enumClass", &NonReflectedEnumWrapper::m_enumClass)
+                ->Field("rawEnum", &NonReflectedEnumWrapper::m_rawEnum);
+        }
+    }
+
+    InstanceWithSomeDefaults<NonReflectedEnumWrapper> NonReflectedEnumWrapper::GetInstanceWithSomeDefaults()
+    {
+        auto instance = AZStd::make_unique<NonReflectedEnumWrapper>();
+        instance->m_enumClass = NonReflectedEnumWrapper::SimpleEnumClass::Option2;
+
+        const char* strippedDefaults = R"(
+            {
+                "enumClass": 2
+            })";
+        const char* keptDefaults = R"(
+            {
+                "enumClass": 2,
+                "rawEnum": 0
+            })";
+
+        return MakeInstanceWithSomeDefaults(AZStd::move(instance),
+            strippedDefaults, keptDefaults);
+    }
+
+    InstanceWithoutDefaults<NonReflectedEnumWrapper> NonReflectedEnumWrapper::GetInstanceWithoutDefaults()
+    {
+        auto instance = AZStd::make_unique<NonReflectedEnumWrapper>();
+        instance->m_enumClass = NonReflectedEnumWrapper::SimpleEnumClass::Option2;
+        instance->m_rawEnum = NonReflectedEnumWrapper::SimpleRawEnum::RawOption1;
+
+        const char* json = R"(
+            {
+                "enumClass": 2,
+                "rawEnum": 1
+            })";
+        return MakeInstanceWithoutDefaults(AZStd::move(instance), json);
+    }
+
     // TemplatedClass<int>
 
     bool TemplatedClass<int>::Equals(const TemplatedClass<int>& rhs, bool fullReflection) const

Code/Framework/AzCore/Tests/Serialization/Json/TestCases_Classes.h

@@ -134,6 +134,35 @@ namespace JsonSerializationTests
         SimpleRawEnum m_rawEnum{};
     };
 
+    struct NonReflectedEnumWrapper
+    {
+        enum class SimpleEnumClass
+        {
+            Option1 = 1,
+            Option2,
+        };
+        enum SimpleRawEnum
+        {
+            RawOption1 = 1,
+            RawOption2,
+        };
+        AZ_CLASS_ALLOCATOR(NonReflectedEnumWrapper, AZ::SystemAllocator, 0);
+        AZ_RTTI(NonReflectedEnumWrapper, "{A80D5B6B-2FD1-46E9-A7A9-44C5E2650526}");
+        
+        static constexpr bool SupportsPartialDefaults = true;
+
+        NonReflectedEnumWrapper() = default;
+        virtual ~NonReflectedEnumWrapper() = default;
+
+        bool Equals(const NonReflectedEnumWrapper& rhs, bool fullReflection) const;
+        static void Reflect(AZStd::unique_ptr<AZ::SerializeContext>& context, bool fullReflection);
+        static InstanceWithSomeDefaults<NonReflectedEnumWrapper> GetInstanceWithSomeDefaults();
+        static InstanceWithoutDefaults<NonReflectedEnumWrapper> GetInstanceWithoutDefaults();
+
+        SimpleEnumClass m_enumClass{};
+        SimpleRawEnum m_rawEnum{};
+    };
+
     template<typename T>
     struct TemplatedClass
     {
@@ -158,5 +187,7 @@ namespace AZ
 {
     AZ_TYPE_INFO_SPECIALIZE(JsonSerializationTests::SimpleEnumWrapper::SimpleEnumClass, "{AF6F1964-5B20-4689-BF23-F36B9C9AAE6A}");
     AZ_TYPE_INFO_SPECIALIZE(JsonSerializationTests::SimpleEnumWrapper::SimpleRawEnum, "{EB24207F-B48F-4D8B-940D-3CD06A371739}");
+    AZ_TYPE_INFO_SPECIALIZE(JsonSerializationTests::NonReflectedEnumWrapper::SimpleEnumClass, "{E80E4A41-B29E-4B7C-B630-3B599172C837}");
+    AZ_TYPE_INFO_SPECIALIZE(JsonSerializationTests::NonReflectedEnumWrapper::SimpleRawEnum, "{C42AF28D-4F84-4540-972A-5B6EEFAB13FF}");
     AZ_TYPE_INFO_TEMPLATE(JsonSerializationTests::TemplatedClass, "{CA4ADF74-66E7-4D16-B4AC-F71278C60EC7}", AZ_TYPE_INFO_TYPENAME);
 }

Code/Framework/AzCore/Tests/Serialization/Json/TransformSerializerTests.cpp

@@ -112,7 +112,7 @@ namespace JsonSerializationTests
         AZ::Transform testTransform = AZ::Transform::CreateIdentity();
         AZ::Transform expectedTransform = 
             AZ::Transform::CreateFromQuaternion(AZ::Quaternion(0.25f, 0.5f, 0.75f, 1.0f));
-        expectedTransform.SetScale(AZ::Vector3(5.5f));
+        expectedTransform.SetUniformScale(5.5f);
 
         rapidjson::Document json;
         json.Parse(R"({ "Rotation": [ 0.25, 0.5, 0.75, 1.0 ], "Scale": 5.5 })");
@@ -128,7 +128,7 @@ namespace JsonSerializationTests
     {
         AZ::Transform testTransform = AZ::Transform::CreateIdentity();
         AZ::Transform expectedTransform = AZ::Transform::CreateTranslation(AZ::Vector3(2.25f, 3.5f, 4.75f));
-        expectedTransform.SetScale(AZ::Vector3(5.5f));
+        expectedTransform.SetUniformScale(5.5f);
 
         rapidjson::Document json;
         json.Parse(R"({ "Translation": [ 2.25, 3.5, 4.75 ], "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/AzCore/Tests/SettingsRegistryMergeUtilsTests.cpp

@@ -372,15 +372,15 @@ mac_remote_filesystem=0
 -- We need to know this before we establish VFS because different platform assets
 -- are stored in different root folders in the cache.  These correspond to the names
 -- In the asset processor config file.  This value also controls what config file is read
--- when you read system_xxxx_xxxx.cfg (for example, system_windows_pc.cfg or system_android_es3.cfg)
+-- when you read system_xxxx_xxxx.cfg (for example, system_windows_pc.cfg or system_android_android.cfg)
 -- by default, pc assets (in the 'pc' folder) are used, with RC being fed 'pc' as the platform
 -- by default on console we use the default assets=pc for better iteration times
 -- we should turn on console specific assets only when in release and/or testing assets and/or loading performance
 -- that way most people will not need to have 3 different caches taking up disk space
 assets = pc
-android_assets = es3
+android_assets = android
 ios_assets = ios
-mac_assets = osx_gl
+mac_assets = mac
 
 -- Add the IP address of your console to the white list that will connect to the asset processor here
 -- You can list addresses or CIDR's. CIDR's are helpful if you are using DHCP. A CIDR looks like an ip address with
@@ -438,9 +438,9 @@ mac_wait_for_connect=0
             ConfigFileParams::SettingsKeyValuePair{"/ios_remote_filesystem", AZ::s64{0}},
             ConfigFileParams::SettingsKeyValuePair{"/mac_remote_filesystem", AZ::s64{0}},
             ConfigFileParams::SettingsKeyValuePair{"/assets", AZStd::string_view{"pc"}},
-            ConfigFileParams::SettingsKeyValuePair{"/android_assets", AZStd::string_view{"es3"}},
+            ConfigFileParams::SettingsKeyValuePair{"/android_assets", AZStd::string_view{"android"}},
             ConfigFileParams::SettingsKeyValuePair{"/ios_assets", AZStd::string_view{"ios"}},
-            ConfigFileParams::SettingsKeyValuePair{"/mac_assets", AZStd::string_view{"osx_gl"}},
+            ConfigFileParams::SettingsKeyValuePair{"/mac_assets", AZStd::string_view{"mac"}},
             ConfigFileParams::SettingsKeyValuePair{"/connect_to_remote", AZ::s64{0}},
             ConfigFileParams::SettingsKeyValuePair{"/windows_connect_to_remote", AZ::s64{1}},
             ConfigFileParams::SettingsKeyValuePair{"/android_connect_to_remote", AZ::s64{0}},
@@ -478,20 +478,20 @@ test_asset_processor_tag = test_value
 [Platform pc]
 tags=tools,renderer,dx12,vulkan
 
-[Platform es3]
+[Platform android]
 tags=android,mobile,renderer,vulkan ; With Comments at the end
 
 [Platform ios]
 tags=mobile,renderer,metal
 
-[Platform osx_gl]
+[Platform mac]
 tags=tools,renderer,metal)"
         , AZStd::fixed_vector<ConfigFileParams::SettingsKeyValuePair, 20>{
             ConfigFileParams::SettingsKeyValuePair{"/test_asset_processor_tag", AZStd::string_view{"test_value"}},
             ConfigFileParams::SettingsKeyValuePair{"/Platform pc/tags", AZStd::string_view{"tools,renderer,dx12,vulkan"}},
-            ConfigFileParams::SettingsKeyValuePair{"/Platform es3/tags", AZStd::string_view{"android,mobile,renderer,vulkan"}},
+            ConfigFileParams::SettingsKeyValuePair{"/Platform android/tags", AZStd::string_view{"android,mobile,renderer,vulkan"}},
             ConfigFileParams::SettingsKeyValuePair{"/Platform ios/tags", AZStd::string_view{"mobile,renderer,metal"}},
-            ConfigFileParams::SettingsKeyValuePair{"/Platform osx_gl/tags", AZStd::string_view{"tools,renderer,metal"}},
+            ConfigFileParams::SettingsKeyValuePair{"/Platform mac/tags", AZStd::string_view{"tools,renderer,metal"}},
         }}
         )
     );

Code/Framework/AzFramework/AzFramework/Application/Application.cpp

@@ -679,8 +679,6 @@ namespace AzFramework
         {
             auto fileIoBase = m_archiveFileIO.get();
             // Set up the default file aliases based on the settings registry
-            fileIoBase->SetAlias("@assets@", "");
-            fileIoBase->SetAlias("@root@", GetEngineRoot());
             fileIoBase->SetAlias("@engroot@", GetEngineRoot());
             fileIoBase->SetAlias("@projectroot@", GetEngineRoot());
             fileIoBase->SetAlias("@exefolder@", GetExecutableFolder());
@@ -694,8 +692,8 @@ namespace AzFramework
                 pathAliases.clear();
                 if (m_settingsRegistry->Get(pathAliases.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_CacheRootFolder))
                 {
-                    fileIoBase->SetAlias("@projectplatformcache@", pathAliases.c_str());
                     fileIoBase->SetAlias("@assets@", pathAliases.c_str());
+                    fileIoBase->SetAlias("@projectplatformcache@", pathAliases.c_str());
                     fileIoBase->SetAlias("@root@", pathAliases.c_str()); // Deprecated Use @projectplatformcache@
                 }
                 pathAliases.clear();

Code/Framework/AzFramework/AzFramework/Archive/Archive.cpp

@@ -2008,13 +2008,12 @@ namespace AZ::IO
         // if no bind root is specified, compute one:
         strBindRoot = !bindRoot.empty() ? bindRoot : szFullPath->ParentPath().Native();
 
-        // Check if archive file disk exist on disk or inside of pak.
-        bool bFileExists = IsFileExist(szFullPath->Native());
-
-        if (!bFileExists && (nFactoryFlags & ZipDir::CacheFactory::FLAGS_READ_ONLY))
+        // Check if archive file disk exist on disk.
+        const bool pakOnDisk = FileIOBase::GetDirectInstance()->Exists(szFullPath->c_str());
+        if (!pakOnDisk && (nFactoryFlags & ZipDir::CacheFactory::FLAGS_READ_ONLY))
         {
             // Archive file not found.
-            AZ_TracePrintf("Archive", "Cannot open Archive file %s\n", szFullPath->c_str());
+            AZ_TracePrintf("Archive", "Archive file %s does not exist\n", szFullPath->c_str());
             return nullptr;
         }
 
@@ -2492,8 +2491,6 @@ namespace AZ::IO
 
     void Archive::FindCompressionInfo(bool& found, AZ::IO::CompressionInfo& info, const AZStd::string_view filename)
     {
-        constexpr uint32_t s_compressionTag = static_cast<uint32_t>('Z') << 24 | static_cast<uint32_t>('C') << 16 | static_cast<uint32_t>('R') << 8 | static_cast<uint32_t>('Y');
-
         if (!found)
         {
             auto correctedFilename = AZ::IO::FileIOBase::GetDirectInstance()->ResolvePath(filename);
@@ -2519,7 +2516,6 @@ namespace AZ::IO
                 found = true;
 
                 info.m_archiveFilename.InitFromRelativePath(archive->GetFilePath());
-                info.m_compressionTag.m_code = s_compressionTag;
                 info.m_offset = pFileData->GetFileDataOffset();
                 info.m_compressedSize = entry->desc.lSizeCompressed;
                 info.m_uncompressedSize = entry->desc.lSizeUncompressed;
@@ -2539,9 +2535,8 @@ namespace AZ::IO
                     break;
                 }
 
-                info.m_decompressor = [&s_compressionTag]([[maybe_unused]] const AZ::IO::CompressionInfo& info, const void* compressed, size_t compressedSize, void* uncompressed, size_t uncompressedBufferSize)->bool
+                info.m_decompressor = []([[maybe_unused]] const AZ::IO::CompressionInfo& info, const void* compressed, size_t compressedSize, void* uncompressed, size_t uncompressedBufferSize)->bool
                 {
-                    AZ_Assert(info.m_compressionTag.m_code == s_compressionTag, "Provided compression info isn't supported by this decompressor.");
                     size_t nSizeUncompressed = uncompressedBufferSize;
                     return ZipDir::ZipRawUncompress(uncompressed, &nSizeUncompressed, compressed, compressedSize) == 0;
                 };

Code/Framework/AzFramework/AzFramework/Archive/ArchiveFindData.cpp

@@ -50,6 +50,7 @@ namespace AZ::IO
         , tWrite{ writeTime }
     {
     }
+
     ArchiveFileIterator::ArchiveFileIterator(FindData* findData, AZStd::string_view filename, const FileDesc& fileDesc)
         : m_findData{ findData }
         , m_filename{ filename }
@@ -108,13 +109,10 @@ namespace AZ::IO
             AZ::StringFunc::Path::GetFullPath(directory.c_str(), searchDirectory);
             AZ::StringFunc::Path::GetFullFileName(directory.c_str(), pattern);
         }
-
         AZ::IO::FileIOBase::GetDirectInstance()->FindFiles(searchDirectory.c_str(), pattern.c_str(), [&](const char* filePath) -> bool
         {
             AZ::IO::FileDesc fileDesc;
-
-            AZStd::string fullFilePath;
-            AZ::StringFunc::Path::GetFullFileName(filePath, fullFilePath);
+            AZStd::string filePathEntry{filePath};
 
             if (AZ::IO::FileIOBase::GetDirectInstance()->IsDirectory(filePath))
             {
@@ -135,9 +133,8 @@ namespace AZ::IO
                 fileDesc.tAccess = fileDesc.tWrite;
                 fileDesc.tCreate = fileDesc.tWrite;
             }
-            [[maybe_unused]] auto result = m_mapFiles.emplace(AZStd::move(fullFilePath), fileDesc);
-            AZ_Assert(result.second, "Failed to insert FindData entry for %s", fullFilePath.c_str());
-
+            [[maybe_unused]] auto result = m_mapFiles.emplace(AZStd::move(filePathEntry), fileDesc);
+            AZ_Assert(result.second, "Failed to insert FindData entry for filePath %s", filePath);
             return true;
         });
     }
@@ -273,7 +270,9 @@ namespace AZ::IO
         }
 
         auto pakFileIter = m_mapFiles.begin();
-        fileIterator.m_filename = pakFileIter->first;
+        AZStd::string fullFilePath;
+        AZ::StringFunc::Path::GetFullFileName(pakFileIter->first.c_str(), fullFilePath);
+        fileIterator.m_filename = AZStd::move(fullFilePath);
         fileIterator.m_fileDesc = pakFileIter->second;
         fileIterator.m_lastFetchValid = true;
 

Code/Framework/AzFramework/AzFramework/Asset/AssetProcessorMessages.cpp

@@ -308,6 +308,56 @@ namespace AzFramework
             }
         }
 
+        //---------------------------------------------------------------------
+        GenerateRelativeSourcePathRequest::GenerateRelativeSourcePathRequest(const AZ::OSString& sourcePath)
+        {
+            AZ_Assert(!sourcePath.empty(), "GenerateRelativeSourcePathRequest: asset path is empty");
+            m_sourcePath = sourcePath;
+        }
+
+        unsigned int GenerateRelativeSourcePathRequest::GetMessageType() const
+        {
+            return MessageType;
+        }
+
+        void GenerateRelativeSourcePathRequest::Reflect(AZ::ReflectContext* context)
+        {
+            auto serialize = azrtti_cast<AZ::SerializeContext*>(context);
+            if (serialize)
+            {
+                serialize->Class<GenerateRelativeSourcePathRequest, BaseAssetProcessorMessage>()
+                    ->Version(1)
+                    ->Field("SourcePath", &GenerateRelativeSourcePathRequest::m_sourcePath);
+            }
+        }
+
+        //---------------------------------------------------------------------
+        GenerateRelativeSourcePathResponse::GenerateRelativeSourcePathResponse(
+            bool resolved, const AZ::OSString& relativeSourcePath, const AZ::OSString& rootFolder)
+        {
+            m_relativeSourcePath = relativeSourcePath;
+            m_resolved = resolved;
+            m_rootFolder = rootFolder;
+        }
+
+        unsigned int GenerateRelativeSourcePathResponse::GetMessageType() const
+        {
+            return GenerateRelativeSourcePathRequest::MessageType;
+        }
+
+        void GenerateRelativeSourcePathResponse::Reflect(AZ::ReflectContext* context)
+        {
+            auto serialize = azrtti_cast<AZ::SerializeContext*>(context);
+            if (serialize)
+            {
+                serialize->Class<GenerateRelativeSourcePathResponse, BaseAssetProcessorMessage>()
+                    ->Version(1)
+                    ->Field("RelativeSourcePath", &GenerateRelativeSourcePathResponse::m_relativeSourcePath)
+                    ->Field("RootFolder", &GenerateRelativeSourcePathResponse::m_rootFolder)
+                    ->Field("Resolved", &GenerateRelativeSourcePathResponse::m_resolved);
+            }
+        }
+
         //---------------------------------------------------------------------
         GetFullSourcePathFromRelativeProductPathRequest::GetFullSourcePathFromRelativeProductPathRequest(const AZ::OSString& relativeProductPath)
         {

Code/Framework/AzFramework/AzFramework/Asset/AssetProcessorMessages.h

@@ -288,6 +288,45 @@ namespace AzFramework
             bool m_resolved;
         };
 
+        //////////////////////////////////////////////////////////////////////////
+        class GenerateRelativeSourcePathRequest : public BaseAssetProcessorMessage
+        {
+        public:
+            AZ_CLASS_ALLOCATOR(GenerateRelativeSourcePathRequest, AZ::OSAllocator, 0);
+            AZ_RTTI(GenerateRelativeSourcePathRequest, "{B3865033-F5A3-4749-8147-7B1AB04D5F6D}",
+                BaseAssetProcessorMessage);
+            static void Reflect(AZ::ReflectContext* context);
+
+            // For people that are debugging the network messages and just see MessageType as a value,
+            // the CRC value below is 739777771 (0x2C181CEB)
+            static constexpr unsigned int MessageType =
+                AZ_CRC_CE("AssetSystem::GenerateRelativeSourcePathRequest");
+
+            GenerateRelativeSourcePathRequest() = default;
+            GenerateRelativeSourcePathRequest(const AZ::OSString& sourcePath);
+            unsigned int GetMessageType() const override;
+
+            AZ::OSString m_sourcePath;
+        };
+
+        class GenerateRelativeSourcePathResponse : public BaseAssetProcessorMessage
+        {
+        public:
+            AZ_CLASS_ALLOCATOR(GenerateRelativeSourcePathResponse, AZ::OSAllocator, 0);
+            AZ_RTTI(GenerateRelativeSourcePathResponse, "{938D33DB-C8F6-4FA4-BC81-2F139A9BE1D7}",
+                BaseAssetProcessorMessage);
+            static void Reflect(AZ::ReflectContext* context);
+
+            GenerateRelativeSourcePathResponse() = default;
+            GenerateRelativeSourcePathResponse(
+                bool resolved, const AZ::OSString& relativeSourcePath, const AZ::OSString& rootFolder);
+            unsigned int GetMessageType() const override;
+
+            AZ::OSString m_relativeSourcePath;
+            AZ::OSString m_rootFolder; ///< This is the folder it was found in (the watched/scanned folder, such as gems /assets/ folder)
+            bool m_resolved;
+        };
+
         //////////////////////////////////////////////////////////////////////////
         class GetFullSourcePathFromRelativeProductPathRequest
             : public BaseAssetProcessorMessage

Code/Framework/AzFramework/AzFramework/Asset/AssetSystemComponent.cpp

@@ -202,6 +202,7 @@ namespace AzFramework
             // Requests
             GetUnresolvedDependencyCountsRequest::Reflect(context);
             GetRelativeProductPathFromFullSourceOrProductPathRequest::Reflect(context);
+            GenerateRelativeSourcePathRequest::Reflect(context);
             GetFullSourcePathFromRelativeProductPathRequest::Reflect(context);
             SourceAssetInfoRequest::Reflect(context);
             AssetInfoRequest::Reflect(context);
@@ -234,6 +235,7 @@ namespace AzFramework
             // Responses
             GetUnresolvedDependencyCountsResponse::Reflect(context);
             GetRelativeProductPathFromFullSourceOrProductPathResponse::Reflect(context);
+            GenerateRelativeSourcePathResponse::Reflect(context);
             GetFullSourcePathFromRelativeProductPathResponse::Reflect(context);
             SourceAssetInfoResponse::Reflect(context);
             AssetInfoResponse::Reflect(context);

Code/Framework/AzFramework/AzFramework/Components/ComponentAdapter.h

@@ -1,22 +1,22 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
 #include <AzCore/Component/Component.h>
 #include <AzCore/RTTI/RTTI.h>
-#include <AzCore/Serialization/SerializeContext.h>
 #include <AzCore/Serialization/EditContext.h>
 #include <AzCore/Serialization/EditContextConstants.inl>
+#include <AzCore/Serialization/SerializeContext.h>
 
 namespace AzFramework
 {
@@ -64,15 +64,13 @@ namespace AzFramework
         the EditContext. TController can friend itself to the editor component to make this work if required.
     */
         template<typename TController, typename TConfiguration = AZ::ComponentConfig>
-        class ComponentAdapter
-            : public AZ::Component
+        class ComponentAdapter : public AZ::Component
         {
         public:
-
             AZ_RTTI((ComponentAdapter, "{644A9187-4FDB-42C1-9D59-DD75304B551A}", TController, TConfiguration), AZ::Component);
 
             ComponentAdapter() = default;
-            ComponentAdapter(const TConfiguration& configuration);
+            explicit ComponentAdapter(const TConfiguration& configuration);
 
             static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& services);
             static void GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& services);
@@ -85,7 +83,6 @@ namespace AzFramework
             void Deactivate() override;
 
         protected:
-
             static void Reflect(AZ::ReflectContext* context);
 
             // AZ::Component overrides ...

Code/Framework/AzFramework/AzFramework/Components/ComponentAdapter.inl

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #include <AzFramework/Components/ComponentAdapterHelpers.h>
 
@@ -32,10 +32,12 @@ namespace AzFramework
 
             if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
             {
+                // clang-format off
                 serializeContext->Class<ComponentAdapter, Component>()
                     ->Version(1)
                     ->Field("Controller", &ComponentAdapter::m_controller)
                     ;
+                // clang-format on
             }
         }
 
@@ -66,9 +68,6 @@ namespace AzFramework
             GetDependentServicesHelper<TController>(services, typename AZ::HasComponentDependentServices<TController>::type());
         }
 
-        //////////////////////////////////////////////////////////////////////////
-        // AZ::Component interface implementation
-
         template<typename TController, typename TConfiguration>
         void ComponentAdapter<TController, TConfiguration>::Init()
         {
@@ -78,7 +77,7 @@ namespace AzFramework
         template<typename TController, typename TConfiguration>
         void ComponentAdapter<TController, TConfiguration>::Activate()
         {
-            m_controller.Activate(GetEntityId());
+            ComponentActivateHelper<TController>::Activate(m_controller, AZ::EntityComponentIdPair(GetEntityId(), GetId()));
         }
 
         template<typename TController, typename TConfiguration>

Code/Framework/AzFramework/AzFramework/Components/ComponentAdapterHelpers.h

@@ -13,6 +13,7 @@
 #pragma once
 
 #include <AzCore/Component/Component.h>
+#include <AzCore/Component/EntityBus.h>
 
 namespace AzFramework
 {
@@ -27,18 +28,43 @@ namespace AzFramework
         template<typename T, typename = void>
         struct ComponentInitHelper
         {
-            static void Init(T& common)
+            static void Init([[maybe_unused]] T& controller)
             {
-                AZ_UNUSED(common);
             }
         };
 
         template<typename T>
         struct ComponentInitHelper<T, AZStd::void_t<decltype(AZStd::declval<T>().Init())>>
         {
-            static void Init(T& common)
+            static void Init(T& controller)
             {
-                common.Init();
+                controller.Init();
+            }
+        };
+
+        template<typename T, typename = void>
+        struct ComponentActivateHelper
+        {
+            static void Activate([[maybe_unused]] T& controller, [[maybe_unused]] const AZ::EntityComponentIdPair& entityComponentIdPair)
+            {
+            }
+        };
+
+        template<typename T>
+        struct ComponentActivateHelper<T, AZStd::void_t<decltype(AZStd::declval<T>().Activate(AZ::EntityId()))>>
+        {
+            static void Activate(T& controller, const AZ::EntityComponentIdPair& entityComponentIdPair)
+            {
+                controller.Activate(entityComponentIdPair.GetEntityId());
+            }
+        };
+
+        template<typename T>
+        struct ComponentActivateHelper<T, AZStd::void_t<decltype(AZStd::declval<T>().Activate(AZ::EntityComponentIdPair()))>>
+        {
+            static void Activate(T& controller, const AZ::EntityComponentIdPair& entityComponentIdPair)
+            {
+                controller.Activate(entityComponentIdPair);
             }
         };
 

Code/Framework/AzFramework/AzFramework/Components/TransformComponent.cpp

@@ -327,99 +327,13 @@ namespace AzFramework
         return localZ;
     }
 
-    void TransformComponent::SetRotation(const AZ::Vector3& eulerAnglesRadian)
+    void TransformComponent::SetWorldRotationQuaternion(const AZ::Quaternion& quaternion)
     {
-        AZ_Warning("TransformComponent", false, "SetRotation is deprecated, please use SetLocalRotation");
-
-        AZ::Transform newWorldTransform = m_worldTM;
-        newWorldTransform.SetRotation(AZ::ConvertEulerRadiansToQuaternion(eulerAnglesRadian));
-        SetWorldTM(newWorldTransform);
-    }
-
-    void TransformComponent::SetRotationQuaternion(const AZ::Quaternion& quaternion)
-    {
-        AZ_Warning("TransformComponent", false, "SetRotationQuaternion is deprecated, please use SetLocalRotationQuaternion");
-
         AZ::Transform newWorldTransform = m_worldTM;
         newWorldTransform.SetRotation(quaternion);
         SetWorldTM(newWorldTransform);
     }
 
-    void TransformComponent::SetRotationX(float eulerAngleRadian)
-    {
-        AZ_Warning("TransformComponent", false, "SetRotationX is deprecated, please use SetLocalRotation");
-
-        AZ::Transform newWorldTransform = m_worldTM;
-        newWorldTransform.SetRotation(AZ::Quaternion::CreateRotationX(eulerAngleRadian));
-        SetWorldTM(newWorldTransform);
-    }
-
-    void TransformComponent::SetRotationY(float eulerAngleRadian)
-    {
-        AZ_Warning("TransformComponent", false, "SetRotationY is deprecated, please use SetLocalRotation");
-
-        AZ::Transform newWorldTransform = m_worldTM;
-        newWorldTransform.SetRotation(AZ::Quaternion::CreateRotationY(eulerAngleRadian));
-        SetWorldTM(newWorldTransform);
-    }
-
-    void TransformComponent::SetRotationZ(float eulerAngleRadian)
-    {
-        AZ_Warning("TransformComponent", false, "SetRotationZ is deprecated, please use SetLocalRotation");
-
-        AZ::Transform newWorldTransform = m_worldTM;
-        newWorldTransform.SetRotation(AZ::Quaternion::CreateRotationZ(eulerAngleRadian));
-        SetWorldTM(newWorldTransform);
-    }
-
-    void TransformComponent::RotateByX(float eulerAngleRadian)
-    {
-        AZ_Warning("TransformComponent", false, "RotateByX is deprecated, please use RotateAroundLocalX");
-        RotateAroundLocalX(eulerAngleRadian);
-    }
-
-    void TransformComponent::RotateByY(float eulerAngleRadian)
-    {
-        AZ_Warning("TransformComponent", false, "RotateByY is deprecated, please use RotateAroundLocalY");
-        RotateAroundLocalY(eulerAngleRadian);
-    }
-
-    void TransformComponent::RotateByZ(float eulerAngleRadian)
-    {
-        AZ_Warning("TransformComponent", false, "RotateByZ is deprecated, please use RotateAroundLocalZ");
-        RotateAroundLocalZ(eulerAngleRadian);
-    }
-
-    AZ::Vector3 TransformComponent::GetRotationEulerRadians()
-    {
-        AZ_Warning("TransformComponent", false, "GetRotationEulerRadians is deprecated, please use GetWorldRotation");
-        return m_worldTM.GetRotation().GetEulerRadians();
-    }
-
-    AZ::Quaternion TransformComponent::GetRotationQuaternion()
-    {
-        AZ_Warning("TransformComponent", false, "GetRotationQuaternion is deprecated, please use GetWorldRotationQuaternion");
-        return m_worldTM.GetRotation();
-    }
-
-    float TransformComponent::GetRotationX()
-    {
-        AZ_Warning("TransformComponent", false, "GetRotationX is deprecated, please use GetWorldRotation");
-        return GetRotationEulerRadians().GetX();
-    }
-
-    float TransformComponent::GetRotationY()
-    {
-        AZ_Warning("TransformComponent", false, "GetRotationY is deprecated, please use GetWorldRotation");
-        return GetRotationEulerRadians().GetY();
-    }
-
-    float TransformComponent::GetRotationZ()
-    {
-        AZ_Warning("TransformComponent", false, "GetRotationZ is deprecated, please use GetWorldRotation");
-        return GetRotationEulerRadians().GetZ();
-    }
-
     AZ::Vector3 TransformComponent::GetWorldRotation()
     {
         return m_worldTM.GetRotation().GetEulerRadians();
@@ -432,46 +346,26 @@ namespace AzFramework
 
     void TransformComponent::SetLocalRotation(const AZ::Vector3& eulerRadianAngles)
     {
-        AZ::Transform newLocalTM = AZ::ConvertEulerRadiansToTransform(eulerRadianAngles);
-        newLocalTM.SetScale(m_localTM.GetScale());
-        newLocalTM.SetTranslation(m_localTM.GetTranslation());
+        AZ::Transform newLocalTM = m_localTM;
+        newLocalTM.SetRotation(AZ::Quaternion::CreateFromEulerAnglesRadians(eulerRadianAngles));
         SetLocalTM(newLocalTM);
     }
 
     void TransformComponent::SetLocalRotationQuaternion(const AZ::Quaternion& quaternion)
     {
-        AZ::Transform newLocalTM;
-        newLocalTM.SetScale(m_localTM.GetScale());
-        newLocalTM.SetTranslation(m_localTM.GetTranslation());
+        AZ::Transform newLocalTM = m_localTM;
         newLocalTM.SetRotation(quaternion);
         SetLocalTM(newLocalTM);
     }
 
     static AZ::Transform RotateAroundLocalHelper(float eulerAngleRadian, const AZ::Transform& localTM, AZ::Vector3 axis)
     {
-        //get the existing translation and scale
-        AZ::Vector3 translation = localTM.GetTranslation();
-        AZ::Vector3 scale = localTM.GetScale();
-
         //normalize the axis before creating rotation
         axis.Normalize();
         AZ::Quaternion rotate = AZ::Quaternion::CreateFromAxisAngle(axis, eulerAngleRadian);
 
-        //create new rotation transform
-        AZ::Quaternion currentRotate = localTM.GetRotation();
-        AZ::Quaternion newRotate = rotate * currentRotate;
-        newRotate.Normalize();
-
-        //scale
-        AZ::Transform newLocalTM = AZ::Transform::CreateScale(scale);
-
-        //rotate
-        AZ::Transform rotateLocalTM = AZ::Transform::CreateFromQuaternion(newRotate);
-        newLocalTM = rotateLocalTM * newLocalTM;
-
-        //translate
-        newLocalTM.SetTranslation(translation);
-
+        AZ::Transform newLocalTM = localTM;
+        newLocalTM.SetRotation((rotate * localTM.GetRotation()).GetNormalized());
         return newLocalTM;
     }
 
@@ -512,75 +406,6 @@ namespace AzFramework
         return m_localTM.GetRotation();
     }
 
-    void TransformComponent::SetScale(const AZ::Vector3& scale)
-    {
-        AZ_Warning("TransformComponent", false, "SetScale is deprecated, please use SetLocalScale");
-
-        if (!m_worldTM.GetScale().IsClose(scale))
-        {
-            AZ::Transform newWorldTransform = m_worldTM;
-            newWorldTransform.SetScale(scale);
-            SetWorldTM(newWorldTransform);
-        }
-    }
-
-    void TransformComponent::SetScaleX(float scaleX)
-    {
-        AZ_Warning("TransformComponent", false, "SetScaleX is deprecated, please use SetLocalScaleX");
-
-        AZ::Vector3 newScale = m_worldTM.GetScale();
-        newScale.SetX(scaleX);
-        AZ::Transform newWorldTransform = m_worldTM;
-        newWorldTransform.SetScale(newScale);
-        SetWorldTM(newWorldTransform);
-    }
-
-    void TransformComponent::SetScaleY(float scaleY)
-    {
-        AZ_Warning("TransformComponent", false, "SetScaleY is deprecated, please use SetLocalScaleY");
-
-        AZ::Vector3 newScale = m_worldTM.GetScale();
-        newScale.SetY(scaleY);
-        AZ::Transform newWorldTransform = m_worldTM;
-        newWorldTransform.SetScale(newScale);
-        SetWorldTM(newWorldTransform);
-    }
-
-    void TransformComponent::SetScaleZ(float scaleZ)
-    {
-        AZ_Warning("TransformComponent", false, "SetScaleZ is deprecated, please use SetLocalScaleZ");
-
-        AZ::Vector3 newScale = m_worldTM.GetScale();
-        newScale.SetZ(scaleZ);
-        AZ::Transform newWorldTransform = m_worldTM;
-        newWorldTransform.SetScale(newScale);
-        SetWorldTM(newWorldTransform);
-    }
-
-    AZ::Vector3 TransformComponent::GetScale()
-    {
-        AZ_Warning("TransformComponent", false, "GetScale is deprecated, please use GetLocalScale");
-        return m_worldTM.GetScale();
-    }
-
-    float TransformComponent::GetScaleX()
-    {
-        AZ_Warning("TransformComponent", false, "GetScaleX is deprecated, please use GetLocalScale");
-        return m_worldTM.GetScale().GetX();
-    }
-
-    float TransformComponent::GetScaleY()
-    {
-        AZ_Warning("TransformComponent", false, "GetScaleY is deprecated, please use GetLocalScale");
-        return m_worldTM.GetScale().GetY();
-    }
-
-    float TransformComponent::GetScaleZ()
-    {
-        AZ_Warning("TransformComponent", false, "GetScaleZ is deprecated, please use GetLocalScale");
-        return m_worldTM.GetScale().GetZ();
-    }
-
     void TransformComponent::SetLocalScale(const AZ::Vector3& scale)
     {
         AZ::Transform newLocalTM = m_localTM;
@@ -588,33 +413,6 @@ namespace AzFramework
         SetLocalTM(newLocalTM);
     }
 
-    void TransformComponent::SetLocalScaleX(float scaleX)
-    {
-        AZ::Transform newLocalTM = m_localTM;
-        AZ::Vector3 newScale = newLocalTM.GetScale();
-        newScale.SetX(scaleX);
-        newLocalTM.SetScale(newScale);
-        SetLocalTM(newLocalTM);
-    }
-
-    void TransformComponent::SetLocalScaleY(float scaleY)
-    {
-        AZ::Transform newLocalTM = m_localTM;
-        AZ::Vector3 newScale = newLocalTM.GetScale();
-        newScale.SetY(scaleY);
-        newLocalTM.SetScale(newScale);
-        SetLocalTM(newLocalTM);
-    }
-
-    void TransformComponent::SetLocalScaleZ(float scaleZ)
-    {
-        AZ::Transform newLocalTM = m_localTM;
-        AZ::Vector3 newScale = newLocalTM.GetScale();
-        newScale.SetZ(scaleZ);
-        newLocalTM.SetScale(newScale);
-        SetLocalTM(newLocalTM);
-    }
-
     AZ::Vector3 TransformComponent::GetLocalScale()
     {
         return m_localTM.GetScale();
@@ -625,6 +423,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;
@@ -929,45 +744,7 @@ namespace AzFramework
                 ->Event("GetLocalX", &AZ::TransformBus::Events::GetLocalX)
                 ->Event("GetLocalY", &AZ::TransformBus::Events::GetLocalY)
                 ->Event("GetLocalZ", &AZ::TransformBus::Events::GetLocalZ)
-                ->Event("RotateByX", &AZ::TransformBus::Events::RotateByX)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("RotateByY", &AZ::TransformBus::Events::RotateByY)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("RotateByZ", &AZ::TransformBus::Events::RotateByZ)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("SetEulerRotation", &AZ::TransformBus::Events::SetRotation)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("SetRotationQuaternion", &AZ::TransformBus::Events::SetRotationQuaternion)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("SetRotationX", &AZ::TransformBus::Events::SetRotationX)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("SetRotationY", &AZ::TransformBus::Events::SetRotationY)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("SetRotationZ", &AZ::TransformBus::Events::SetRotationZ)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("GetEulerRotation", &AZ::TransformBus::Events::GetRotationEulerRadians)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("GetRotationQuaternion", &AZ::TransformBus::Events::GetRotationQuaternion)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("GetRotationX", &AZ::TransformBus::Events::GetRotationX)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                   ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("GetRotationY", &AZ::TransformBus::Events::GetRotationY)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("GetRotationZ", &AZ::TransformBus::Events::GetRotationZ)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
+                ->Event("SetWorldRotationQuaternion", &AZ::TransformBus::Events::SetWorldRotationQuaternion)
                 ->Event("GetWorldRotation", &AZ::TransformBus::Events::GetWorldRotation)
                 ->Event("GetWorldRotationQuaternion", &AZ::TransformBus::Events::GetWorldRotationQuaternion)
                 ->Event("SetLocalRotation", &AZ::TransformBus::Events::SetLocalRotation)
@@ -979,34 +756,7 @@ namespace AzFramework
                 ->Event("GetLocalRotationQuaternion", &AZ::TransformBus::Events::GetLocalRotationQuaternion)
                     ->Attribute("Rotation", AZ::Edit::Attributes::PropertyRotation)
                 ->VirtualProperty("Rotation", "GetLocalRotationQuaternion", "SetLocalRotationQuaternion")
-                ->Event("SetScale", &AZ::TransformBus::Events::SetScale)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("SetScaleX", &AZ::TransformBus::Events::SetScaleX)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("SetScaleY", &AZ::TransformBus::Events::SetScaleY)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("SetScaleZ", &AZ::TransformBus::Events::SetScaleZ)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("GetScale", &AZ::TransformBus::Events::GetScale)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("GetScaleX", &AZ::TransformBus::Events::GetScaleX)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("GetScaleY", &AZ::TransformBus::Events::GetScaleY)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("GetScaleZ", &AZ::TransformBus::Events::GetScaleZ)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
                 ->Event("SetLocalScale", &AZ::TransformBus::Events::SetLocalScale)
-                ->Event("SetLocalScaleX", &AZ::TransformBus::Events::SetLocalScaleX)
-                ->Event("SetLocalScaleY", &AZ::TransformBus::Events::SetLocalScaleY)
-                ->Event("SetLocalScaleZ", &AZ::TransformBus::Events::SetLocalScaleZ)
                 ->Event("GetLocalScale", &AZ::TransformBus::Events::GetLocalScale)
                     ->Attribute("Scale", AZ::Edit::Attributes::PropertyScale)
                 ->VirtualProperty("Scale", "GetLocalScale", "SetLocalScale")

Code/Framework/AzFramework/AzFramework/Components/TransformComponent.h

@@ -112,22 +112,7 @@ namespace AzFramework
         float GetLocalZ() override;
 
         // Rotation modifiers
-        void SetRotation(const AZ::Vector3& eulerAnglesRadian) override;
-        void SetRotationQuaternion(const AZ::Quaternion& quaternion) override;
-        void SetRotationX(float eulerAngleRadian) override;
-        void SetRotationY(float eulerAngleRadian) override;
-        void SetRotationZ(float eulerAngleRadian) override;
-
-        void RotateByX(float eulerAngleRadian) override;
-        void RotateByY(float eulerAngleRadian) override;
-        void RotateByZ(float eulerAngleRadian) override;
-
-        AZ::Vector3 GetRotationEulerRadians() override;
-        AZ::Quaternion GetRotationQuaternion() override;
-
-        float GetRotationX() override;
-        float GetRotationY() override;
-        float GetRotationZ() override;
+        void SetWorldRotationQuaternion(const AZ::Quaternion& quaternion) override;
 
         AZ::Vector3 GetWorldRotation() override;
         AZ::Quaternion GetWorldRotationQuaternion() override;
@@ -143,24 +128,14 @@ namespace AzFramework
         AZ::Quaternion GetLocalRotationQuaternion() override;
 
         // Scale Modifiers
-        void SetScale(const AZ::Vector3& scale) override;
-        void SetScaleX(float scaleX) override;
-        void SetScaleY(float scaleY) override;
-        void SetScaleZ(float scaleZ) override;
-
-        AZ::Vector3 GetScale() override;
-        float GetScaleX() override;
-        float GetScaleY() override;
-        float GetScaleZ() override;
-
         void SetLocalScale(const AZ::Vector3& scale) override;
-        void SetLocalScaleX(float scaleX) override;
-        void SetLocalScaleY(float scaleY) override;
-        void SetLocalScaleZ(float scaleZ) override;
-
         AZ::Vector3 GetLocalScale() override;
         AZ::Vector3 GetWorldScale() override;
 
+        void SetLocalUniformScale(float scale) override;
+        float GetLocalUniformScale() override;
+        float GetWorldUniformScale() override;
+
         // Transform hierarchy
         AZStd::vector<AZ::EntityId> GetChildren() override;
         AZStd::vector<AZ::EntityId> GetAllDescendants() override;

Code/Framework/AzFramework/AzFramework/Entity/EntityDebugDisplayBus.h

@@ -60,6 +60,7 @@ namespace AzFramework
         virtual void DrawTrianglesIndexed(const AZStd::vector<AZ::Vector3>& vertices, const AZStd::vector<AZ::u32>& indices, const AZ::Color& color) { (void)vertices; (void)indices, (void)color; }
         virtual void DrawWireBox(const AZ::Vector3& min, const AZ::Vector3& max) { (void)min; (void)max; }
         virtual void DrawSolidBox(const AZ::Vector3& min, const AZ::Vector3& max) { (void)min; (void)max; }
+        virtual void DrawWireOBB(const AZ::Vector3& center, const AZ::Vector3& axisX, const AZ::Vector3& axisY, const AZ::Vector3& axisZ, const AZ::Vector3& halfExtents) { (void)center; (void)axisX; (void)axisY; (void)axisZ; (void)halfExtents; }
         virtual void DrawSolidOBB(const AZ::Vector3& center, const AZ::Vector3& axisX, const AZ::Vector3& axisY, const AZ::Vector3& axisZ, const AZ::Vector3& halfExtents) { (void)center; (void)axisX; (void)axisY; (void)axisZ; (void)halfExtents; }
         virtual void DrawPoint(const AZ::Vector3& p, int nSize = 1) { (void)p; (void)nSize; }
         virtual void DrawLine(const AZ::Vector3& p1, const AZ::Vector3& p2) { (void)p1; (void)p2; }
@@ -70,18 +71,15 @@ namespace AzFramework
         virtual void DrawLine2d(const AZ::Vector2& p1, const AZ::Vector2& p2, float z) { (void)p1; (void)p2; (void)z; }
         virtual void DrawLine2dGradient(const AZ::Vector2& p1, const AZ::Vector2& p2, float z, const AZ::Vector4& firstColor, const AZ::Vector4& secondColor) { (void)p1; (void)p2; (void)z; (void)firstColor; (void)secondColor; }
         virtual void DrawWireCircle2d(const AZ::Vector2& center, float radius, float z) { (void)center; (void)radius; (void)z; }
-        virtual void DrawTerrainCircle(const AZ::Vector3& worldPos, float radius, float height) { (void)worldPos; (void)radius; (void)height; }
-        virtual void DrawTerrainCircle(const AZ::Vector3& center, float radius, float angle1, float angle2, float height) { (void)center; (void)radius; (void)angle1; (void)angle2; (void)height; }
         virtual void DrawArc(const AZ::Vector3& pos, float radius, float startAngleDegrees, float sweepAngleDegrees, float angularStepDegrees, int referenceAxis = 2) { (void)pos; (void)radius; (void)startAngleDegrees; (void)sweepAngleDegrees; (void)angularStepDegrees; (void)referenceAxis; }
         virtual void DrawArc(const AZ::Vector3& pos, float radius, float startAngleDegrees, float sweepAngleDegrees, float angularStepDegrees, const AZ::Vector3& fixedAxis) { (void)pos; (void)radius; (void)startAngleDegrees; (void)sweepAngleDegrees; (void)angularStepDegrees; (void)fixedAxis; }
         virtual void DrawCircle(const AZ::Vector3& pos, float radius, int nUnchangedAxis = 2 /*z axis*/) { (void)pos; (void)radius; (void)nUnchangedAxis; }
         virtual void DrawHalfDottedCircle(const AZ::Vector3& pos, float radius, const AZ::Vector3& viewPos, int nUnchangedAxis = 2 /*z axis*/) { (void)pos; (void)radius; (void)viewPos; (void)nUnchangedAxis; }
-        virtual void DrawCone(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius, float height, bool drawShaded = true) { (void)pos; (void)dir; (void)radius; (void)height; (void)drawShaded; }
+        virtual void DrawWireCone(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius, float height) { (void)pos; (void)dir; (void)radius; (void)height; }
+        virtual void DrawSolidCone(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius, float height, bool drawShaded = true) { (void)pos; (void)dir; (void)radius; (void)height; (void)drawShaded; }
         virtual void DrawWireCylinder(const AZ::Vector3& center, const AZ::Vector3& axis, float radius, float height) { (void)center; (void)axis; (void)radius; (void)height; }
         virtual void DrawSolidCylinder(const AZ::Vector3& center, const AZ::Vector3& axis, float radius, float height, bool drawShaded = true) { (void)center; (void)axis; (void)radius; (void)height; (void)drawShaded; }
         virtual void DrawWireCapsule(const AZ::Vector3& center, const AZ::Vector3& axis, float radius, float heightStraightSection) { (void)center; (void)axis; (void)radius; (void)heightStraightSection; }
-        virtual void DrawTerrainRect(float x1, float y1, float x2, float y2, float height) { (void)x1; (void)y1; (void)x2; (void)y2; (void)height; }
-        virtual void DrawTerrainLine(AZ::Vector3 worldPos1, AZ::Vector3 worldPos2) { (void)worldPos1; (void)worldPos2; }
         virtual void DrawWireSphere(const AZ::Vector3& pos, float radius) { (void)pos; (void)radius; }
         virtual void DrawWireSphere(const AZ::Vector3& pos, const AZ::Vector3 radius) { (void)pos; (void)radius; }
         virtual void DrawWireDisk(const AZ::Vector3& pos, const AZ::Vector3& dir, float radius) { (void)pos; (void)dir; (void)radius; }
@@ -91,11 +89,8 @@ namespace AzFramework
         virtual void DrawTextLabel(const AZ::Vector3& pos, float size, const char* text, const bool bCenter = false, int srcOffsetX = 0, int srcOffsetY = 0) { (void)pos; (void)size; (void)text; (void)bCenter; (void)srcOffsetX; (void)srcOffsetY; }
         virtual void Draw2dTextLabel(float x, float y, float size, const char* text, bool bCenter = false) { (void)x; (void)y; (void)size; (void)text; (void)bCenter; }
         virtual void DrawTextOn2DBox(const AZ::Vector3& pos, const char* text, float textScale, const AZ::Vector4& TextColor, const AZ::Vector4& TextBackColor) { (void)pos; (void)text; (void)textScale; (void)TextColor; (void)TextBackColor; }
-        virtual void DrawTextureLabel(ITexture* texture, const AZ::Vector3& pos, float sizeX, float sizeY, int texIconFlags) { (void)texture; (void)pos; (void)sizeX; (void)sizeY; (void)texIconFlags; }
-        virtual void DrawTextureLabel(int textureId, const AZ::Vector3& pos, float sizeX, float sizeY, int texIconFlags) { (void)textureId; (void)pos; (void)sizeX; (void)sizeY; (void)texIconFlags; }
         virtual void SetLineWidth(float width) { (void)width; }
         virtual bool IsVisible(const AZ::Aabb& bounds) { (void)bounds; return false; }
-        virtual int SetFillMode(int nFillMode) { (void)nFillMode; return 0; }
         virtual float GetLineWidth() { return 0.0f; }
         virtual float GetAspectRatio() { return 0.0f; }
         virtual void DepthTestOff() {}

Code/Framework/AzFramework/AzFramework/Font/FontInterface.h

@@ -15,6 +15,7 @@
 #include <AzCore/RTTI/RTTI.h>
 #include <AzCore/Math/Vector2.h>
 #include <AzCore/Math/Color.h>
+#include <AzCore/Math/Matrix3x4.h>
 #include <AzCore/std/string/string_view.h>
 #include <AzFramework/Viewport/ViewportId.h>
 
@@ -42,11 +43,15 @@ namespace AzFramework
     {
         ViewportId m_drawViewportId = InvalidViewportId; //!< Viewport to draw into
         AZ::Vector3 m_position; //!< world space position for 3d draws, screen space x,y,depth for 2d.
-        AZ::Color   m_color = AZ::Colors::White; //!< Color to draw the text
+        AZ::Color m_color = AZ::Colors::White; //!< Color to draw the text
+        unsigned int m_effectIndex = 0; //!< effect index to apply
         AZ::Vector2 m_scale = AZ::Vector2(1.0f); //!< font scale
-        float       m_lineSpacing; //!< Spacing between new lines, as a percentage of m_scale.
+        float m_textSizeFactor = 12.0f; //!< font size in pixels
+        float m_lineSpacing = 1.0f; //!< Spacing between new lines, as a percentage of m_scale.
         TextHorizontalAlignment m_hAlign = TextHorizontalAlignment::Left; //!< Horizontal text alignment
         TextVerticalAlignment m_vAlign = TextVerticalAlignment::Top; //!< Vertical text alignment
+        bool m_useTransform = false; //!< Use specified transform
+        AZ::Matrix3x4 m_transform = AZ::Matrix3x4::Identity(); //!< Transform to apply to text quads
         bool m_monospace = false; //!< disable character proportional spacing
         bool m_depthTest = false; //!< Test character against the depth buffer
         bool m_virtual800x600ScreenSize = true; //!< Text placement and size are scaled relative to a virtual 800x600 resolution

Code/Framework/AzFramework/AzFramework/Physics/Ragdoll.h

@@ -102,7 +102,7 @@ namespace Physics
 
         /// Is the ragdoll currently simulated?
         /// @result True in case the ragdoll is simulated, false if not.
-        virtual bool IsSimulated() = 0;
+        virtual bool IsSimulated() const = 0;
 
         /// Writes the state for all of the bodies in the ragdoll to the provided output.
         /// The caller owns the output state and can safely manipulate it without affecting the physics simulation.

Code/Framework/AzFramework/AzFramework/ProjectManager/ProjectManager.cpp

@@ -46,7 +46,6 @@ namespace AzFramework::ProjectManager
             // Store the Command line to the Setting Registry
             AZ::SettingsRegistryImpl settingsRegistry;
             AZ::SettingsRegistryMergeUtils::StoreCommandLineToRegistry(settingsRegistry, commandLine);
-            AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_Bootstrap(settingsRegistry);
             AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_O3deUserRegistry(settingsRegistry, AZ_TRAIT_OS_PLATFORM_CODENAME, {});
             // Retrieve Command Line from Settings Registry, it may have been updated by the call to FindEngineRoot()
             // in MergeSettingstoRegistry_ConfigFile
@@ -99,51 +98,18 @@ namespace AzFramework::ProjectManager
             AZ::AllocatorInstance<AZ::SystemAllocator>::Create();
         }
         {
-            const char projectsScript[] = "projects.py";
+            AZStd::string filename = "o3de";
+            AZ::IO::FixedMaxPath executablePath = AZ::Utils::GetExecutableDirectory();
+            executablePath /= filename + AZ_TRAIT_OS_EXECUTABLE_EXTENSION;
 
-            AZ_Warning("ProjectManager", false, "No project provided - launching project selector.");
-
-            if (engineRootPath.empty())
+            if (!AZ::IO::SystemFile::Exists(executablePath.c_str()))
             {
-                AZ_Error("ProjectManager", false, "Couldn't find engine root");
+                AZ_Error("ProjectManager", false, "%s not found", executablePath.c_str());
                 return false;
             }
-            auto projectManagerPath = engineRootPath / "scripts" / "project_manager";
-
-            if (!AZ::IO::SystemFile::Exists((projectManagerPath / projectsScript).c_str()))
-            {
-                AZ_Error("ProjectManager", false, "%s not found at %s!", projectsScript, projectManagerPath.c_str());
-                return false;
-            }
-            AZ::IO::FixedMaxPathString executablePath;
-            AZ::Utils::GetExecutablePathReturnType result = AZ::Utils::GetExecutablePath(executablePath.data(), executablePath.capacity());
-            if (result.m_pathStored != AZ::Utils::ExecutablePathResult::Success)
-            {
-                AZ_Error("ProjectManager", false, "Could not determine executable path!");
-                return false;
-            }
-            AZ::IO::FixedMaxPath parentPath(executablePath.c_str());
-            auto exeFolder = parentPath.ParentPath();
-            AZStd::fixed_string<8> debugOption;
-            auto lastSep = exeFolder.Native().find_last_of(AZ_CORRECT_FILESYSTEM_SEPARATOR);
-            if (lastSep != AZStd::string_view::npos)
-            {
-                exeFolder = exeFolder.Native().substr(lastSep + 1);
-            }
-            if (exeFolder == "debug")
-            {
-                // We need to use the debug version of the python interpreter to load up our debug version of our libraries which work with the debug version of QT living in this folder
-                debugOption = "debug ";
-            }
-            AZ::IO::FixedMaxPath pythonPath = engineRootPath / "python";
-            pythonPath /= AZ_TRAIT_AZFRAMEWORK_PYTHON_SHELL;
-            auto cmdPath = AZ::IO::FixedMaxPathString::format("%s %s%s --executable_path=%s --parent_pid=%" PRIu32, pythonPath.Native().c_str(),
-                debugOption.c_str(), (projectManagerPath / projectsScript).c_str(), executablePath.c_str(), AZ::Platform::GetCurrentProcessId());
 
             AzFramework::ProcessLauncher::ProcessLaunchInfo processLaunchInfo;
-
-            processLaunchInfo.m_commandlineParameters = cmdPath;
-            processLaunchInfo.m_showWindow = false;
+            processLaunchInfo.m_commandlineParameters = executablePath.String();
             launchSuccess = AzFramework::ProcessLauncher::LaunchUnwatchedProcess(processLaunchInfo);
         }
         if (ownsSystemAllocator)

Code/Framework/AzFramework/AzFramework/Render/GeometryIntersectionBus.h

@@ -12,6 +12,7 @@
 #pragma once
 
 #include <AzCore/EBus/EBus.h>
+#include <AzFramework/Entity/EntityContextBus.h>
 #include <AzFramework/Render/GeometryIntersectionStructures.h>
 
 namespace AzFramework
@@ -35,12 +36,12 @@ namespace AzFramework
             AzFramework::EntityContextId m_contextId;
         };
 
-        //! Interface for intersection requests, implement this interface for making your component
-        //! render geometry intersectable.
+        //! Interface for intersection requests.
+        //! Implement this interface to make your component 'intersectable'.
         class IntersectionRequests
             : public AZ::EBusTraits
         {
-            //! Policy for notifying the Intersector bus of entities connected/disconnected to this ebus
+            //! Policy for notifying the Intersector bus of entities connected/disconnected to this EBus
             //! so it updates the internal data of the entities
             template<class Bus>
             struct IntersectionRequestsConnectionPolicy

Code/Framework/AzFramework/AzFramework/Spawnable/Spawnable.h

@@ -19,10 +19,13 @@
 #include <AzCore/std/smart_ptr/unique_ptr.h>
 #include <AzFramework/Spawnable/SpawnableMetaData.h>
 
-namespace AzFramework
+namespace AZ
 {
     class ReflectContext;
+}
 
+namespace AzFramework
+{
     class Spawnable final
         : public AZ::Data::AssetData
     {

Code/Framework/AzFramework/AzFramework/Spawnable/SpawnableEntitiesInterface.cpp

@@ -14,6 +14,10 @@
 
 namespace AzFramework
 {
+    //
+    // SpawnableEntityContainerView
+    //
+
     SpawnableEntityContainerView::SpawnableEntityContainerView(AZ::Entity** begin, size_t length)
         : m_begin(begin)
         , m_end(begin + length)
@@ -52,6 +56,9 @@ namespace AzFramework
     }
 
 
+    //
+    // SpawnableConstEntityContainerView
+    //
 
     SpawnableConstEntityContainerView::SpawnableConstEntityContainerView(AZ::Entity** begin, size_t length)
         : m_begin(begin)
@@ -91,6 +98,136 @@ namespace AzFramework
     }
 
 
+    //
+    // SpawnableIndexEntityPair
+    //
+
+    SpawnableIndexEntityPair::SpawnableIndexEntityPair(AZ::Entity** entityIterator, size_t* indexIterator)
+        : m_entity(entityIterator)
+        , m_index(indexIterator)
+    {
+    }
+
+    AZ::Entity* SpawnableIndexEntityPair::GetEntity()
+    {
+        return *m_entity;
+    }
+
+    const AZ::Entity* SpawnableIndexEntityPair::GetEntity() const
+    {
+        return *m_entity;
+    }
+
+    size_t SpawnableIndexEntityPair::GetIndex() const
+    {
+        return *m_index;
+    }
+
+    //
+    // SpawnableIndexEntityIterator
+    //
+
+    SpawnableIndexEntityIterator::SpawnableIndexEntityIterator(AZ::Entity** entityIterator, size_t* indexIterator)
+        : m_value(entityIterator, indexIterator)
+    {
+    }
+
+    SpawnableIndexEntityIterator& SpawnableIndexEntityIterator::operator++()
+    {
+        ++m_value.m_entity;
+        ++m_value.m_index;
+        return *this;
+    }
+
+    SpawnableIndexEntityIterator SpawnableIndexEntityIterator::operator++(int)
+    {
+        SpawnableIndexEntityIterator result = *this;
+        ++m_value.m_entity;
+        ++m_value.m_index;
+        return result;
+    }
+
+    SpawnableIndexEntityIterator& SpawnableIndexEntityIterator::operator--()
+    {
+        --m_value.m_entity;
+        --m_value.m_index;
+        return *this;
+    }
+
+    SpawnableIndexEntityIterator SpawnableIndexEntityIterator::operator--(int)
+    {
+        SpawnableIndexEntityIterator result = *this;
+        --m_value.m_entity;
+        --m_value.m_index;
+        return result;
+    }
+
+    bool SpawnableIndexEntityIterator::operator==(const SpawnableIndexEntityIterator& rhs)
+    {
+        return m_value.m_entity == rhs.m_value.m_entity && m_value.m_index == rhs.m_value.m_index;
+    }
+
+    bool SpawnableIndexEntityIterator::operator!=(const SpawnableIndexEntityIterator& rhs)
+    {
+        return m_value.m_entity != rhs.m_value.m_entity || m_value.m_index != rhs.m_value.m_index;
+    }
+
+    SpawnableIndexEntityPair& SpawnableIndexEntityIterator::operator*()
+    {
+        return m_value;
+    }
+
+    const SpawnableIndexEntityPair& SpawnableIndexEntityIterator::operator*() const
+    {
+        return m_value;
+    }
+
+    SpawnableIndexEntityPair* SpawnableIndexEntityIterator::operator->()
+    {
+        return &m_value;
+    }
+
+    const SpawnableIndexEntityPair* SpawnableIndexEntityIterator::operator->() const
+    {
+        return &m_value;
+    }
+
+
+    //
+    // SpawnableConstIndexEntityContainerView
+    //
+
+    SpawnableConstIndexEntityContainerView::SpawnableConstIndexEntityContainerView(
+        AZ::Entity** beginEntity, size_t* beginIndices, size_t length)
+        : m_begin(beginEntity, beginIndices)
+        , m_end(beginEntity + length, beginIndices + length)
+    {
+    }
+
+    const SpawnableIndexEntityIterator& SpawnableConstIndexEntityContainerView::begin()
+    {
+        return m_begin;
+    }
+
+    const SpawnableIndexEntityIterator& SpawnableConstIndexEntityContainerView::end()
+    {
+        return m_end;
+    }
+
+    const SpawnableIndexEntityIterator& SpawnableConstIndexEntityContainerView::cbegin()
+    {
+        return m_begin;
+    }
+
+    const SpawnableIndexEntityIterator& SpawnableConstIndexEntityContainerView::cend()
+    {
+        return m_end;
+    }
+
+
+    //
+    // EntitySpawnTicket
+    //
 
     EntitySpawnTicket::EntitySpawnTicket(EntitySpawnTicket&& rhs)
         : m_payload(rhs.m_payload)

Code/Framework/AzFramework/AzFramework/Spawnable/SpawnableEntitiesInterface.h

@@ -58,6 +58,72 @@ namespace AzFramework
         AZ::Entity** m_end;
     };
 
+    class SpawnableIndexEntityPair
+    {
+    public:
+        friend class SpawnableIndexEntityIterator;
+
+        AZ::Entity* GetEntity();
+        const AZ::Entity* GetEntity() const;
+        size_t GetIndex() const;
+
+    private:
+        SpawnableIndexEntityPair() = default;
+        SpawnableIndexEntityPair(const SpawnableIndexEntityPair&) = default;
+        SpawnableIndexEntityPair(SpawnableIndexEntityPair&&) = default;
+        SpawnableIndexEntityPair(AZ::Entity** entityIterator, size_t* indexIterator);
+
+        SpawnableIndexEntityPair& operator=(const SpawnableIndexEntityPair&) = default;
+        SpawnableIndexEntityPair& operator=(SpawnableIndexEntityPair&&) = default;
+
+        AZ::Entity** m_entity { nullptr };
+        size_t* m_index { nullptr };
+    };
+
+    class SpawnableIndexEntityIterator
+    {
+    public:
+        // Limited to bidirectional iterator as there's no use case for extending it further, but can be extended if a use case is found.
+        using iterator_category = AZStd::bidirectional_iterator_tag;
+        using value_type = SpawnableIndexEntityPair;
+        using difference_type = size_t;
+        using pointer = SpawnableIndexEntityPair*;
+        using reference = SpawnableIndexEntityPair&;
+
+        SpawnableIndexEntityIterator(AZ::Entity** entityIterator, size_t* indexIterator);
+
+        SpawnableIndexEntityIterator& operator++();
+        SpawnableIndexEntityIterator operator++(int);
+        SpawnableIndexEntityIterator& operator--();
+        SpawnableIndexEntityIterator operator--(int);
+
+        bool operator==(const SpawnableIndexEntityIterator& rhs);
+        bool operator!=(const SpawnableIndexEntityIterator& rhs);
+
+        SpawnableIndexEntityPair& operator*();
+        const SpawnableIndexEntityPair& operator*() const;
+        SpawnableIndexEntityPair* operator->();
+        const SpawnableIndexEntityPair* operator->() const;
+
+    private:
+        SpawnableIndexEntityPair m_value;
+    };
+
+    class SpawnableConstIndexEntityContainerView
+    {
+    public:
+        SpawnableConstIndexEntityContainerView(AZ::Entity** beginEntity, size_t* beginIndices, size_t length);
+
+        const SpawnableIndexEntityIterator& begin();
+        const SpawnableIndexEntityIterator& end();
+        const SpawnableIndexEntityIterator& cbegin();
+        const SpawnableIndexEntityIterator& cend();
+
+    private:
+        SpawnableIndexEntityIterator m_begin;
+        SpawnableIndexEntityIterator m_end;
+    };
+
     //! Requests to the SpawnableEntitiesInterface require a ticket with a valid spawnable that be used as a template. A ticket can
     //! be reused for multiple calls on the same spawnable and is safe to use by multiple threads at the same time. Entities created
     //! from the spawnable may be tracked by the ticket and so using the same ticket is needed to despawn the exact entities created
@@ -88,6 +154,7 @@ namespace AzFramework
     using EntityDespawnCallback = AZStd::function<void(EntitySpawnTicket&)>;
     using ReloadSpawnableCallback = AZStd::function<void(EntitySpawnTicket&, SpawnableConstEntityContainerView)>;
     using ListEntitiesCallback = AZStd::function<void(EntitySpawnTicket&, SpawnableConstEntityContainerView)>;
+    using ListIndicesEntitiesCallback = AZStd::function<void(EntitySpawnTicket&, SpawnableConstIndexEntityContainerView)>;
     using ClaimEntitiesCallback = AZStd::function<void(EntitySpawnTicket&, SpawnableEntityContainerView)>;
     using BarrierCallback = AZStd::function<void(EntitySpawnTicket&)>;
 
@@ -140,6 +207,15 @@ namespace AzFramework
         //! @param ticket Only the entities associated with this ticket will be listed.
         //! @param listCallback Required callback that will be called to list the entities on.
         virtual void ListEntities(EntitySpawnTicket& ticket, ListEntitiesCallback listCallback) = 0;
+        //! List all entities that are spawned using this ticket with their spawnable index.
+        //!     Spawnables contain a flat list of entities, which are used as templates to spawn entities from. For every spawned entity
+        //!     the index of the entity in the spawnable that was used as a template is stored. This version of ListEntities will return
+        //!     both the entities and this index. The index can be used with SpawnEntities to create the same entities again. Note that
+        //!     the same index may appear multiple times as there are no restriction on how many instance of a specific entity can be
+        //!     created.
+        //! @param ticket Only the entities associated with this ticket will be listed.
+        //! @param listCallback Required callback that will be called to list the entities and indices on.
+        virtual void ListIndicesAndEntities(EntitySpawnTicket& ticket, ListIndicesEntitiesCallback listCallback) = 0;
         //! Claim all entities that are spawned using this ticket. Ownership of the entities is transferred from the ticket to the
         //!     caller through the callback. After this call the ticket will have no entities associated with it. The caller of
         //!     this function will need to manage the entities after this call.

Code/Framework/AzFramework/AzFramework/Spawnable/SpawnableEntitiesManager.cpp

@@ -25,6 +25,8 @@ namespace AzFramework
     void SpawnableEntitiesManager::SpawnAllEntities(EntitySpawnTicket& ticket, EntityPreInsertionCallback preInsertionCallback,
         EntitySpawnCallback completionCallback)
     {
+        AZ_Assert(ticket.IsValid(), "Ticket provided to SpawnAllEntities hasn't been initialized.");
+
         SpawnAllEntitiesCommand queueEntry;
         queueEntry.m_ticket = &ticket;
         queueEntry.m_completionCallback = AZStd::move(completionCallback);
@@ -40,6 +42,8 @@ namespace AzFramework
         EntitySpawnTicket& ticket, AZStd::vector<size_t> entityIndices,
         EntityPreInsertionCallback preInsertionCallback, EntitySpawnCallback completionCallback)
     {
+        AZ_Assert(ticket.IsValid(), "Ticket provided to SpawnEntities hasn't been initialized.");
+
         SpawnEntitiesCommand queueEntry;
         queueEntry.m_ticket = &ticket;
         queueEntry.m_entityIndices = AZStd::move(entityIndices);
@@ -54,6 +58,8 @@ namespace AzFramework
 
     void SpawnableEntitiesManager::DespawnAllEntities(EntitySpawnTicket& ticket, EntityDespawnCallback completionCallback)
     {
+        AZ_Assert(ticket.IsValid(), "Ticket provided to DespawnAllEntities hasn't been initialized.");
+
         DespawnAllEntitiesCommand queueEntry;
         queueEntry.m_ticket = &ticket;
         queueEntry.m_completionCallback = AZStd::move(completionCallback);
@@ -67,6 +73,8 @@ namespace AzFramework
     void SpawnableEntitiesManager::ReloadSpawnable(EntitySpawnTicket& ticket, AZ::Data::Asset<Spawnable> spawnable,
         ReloadSpawnableCallback completionCallback)
     {
+        AZ_Assert(ticket.IsValid(), "Ticket provided to ReloadSpawnable hasn't been initialized.");
+
         ReloadSpawnableCommand queueEntry;
         queueEntry.m_ticket = &ticket;
         queueEntry.m_spawnable = AZStd::move(spawnable);
@@ -81,6 +89,7 @@ namespace AzFramework
     void SpawnableEntitiesManager::ListEntities(EntitySpawnTicket& ticket, ListEntitiesCallback listCallback)
     {
         AZ_Assert(listCallback, "ListEntities called on spawnable entities without a valid callback to use.");
+        AZ_Assert(ticket.IsValid(), "Ticket provided to ListEntities hasn't been initialized.");
 
         ListEntitiesCommand queueEntry;
         queueEntry.m_ticket = &ticket;
@@ -92,9 +101,25 @@ namespace AzFramework
         }
     }
 
+    void SpawnableEntitiesManager::ListIndicesAndEntities(EntitySpawnTicket& ticket, ListIndicesEntitiesCallback listCallback)
+    {
+        AZ_Assert(listCallback, "ListEntities called on spawnable entities without a valid callback to use.");
+        AZ_Assert(ticket.IsValid(), "Ticket provided to ListEntities hasn't been initialized.");
+
+        ListIndicesEntitiesCommand queueEntry;
+        queueEntry.m_ticket = &ticket;
+        queueEntry.m_listCallback = AZStd::move(listCallback);
+        {
+            AZStd::scoped_lock queueLock(m_pendingRequestQueueMutex);
+            queueEntry.m_ticketId = GetTicketPayload<Ticket>(ticket).m_nextTicketId++;
+            m_pendingRequestQueue.push(AZStd::move(queueEntry));
+        }
+    }
+
     void SpawnableEntitiesManager::ClaimEntities(EntitySpawnTicket& ticket, ClaimEntitiesCallback listCallback)
     {
         AZ_Assert(listCallback, "ClaimEntities called on spawnable entities without a valid callback to use.");
+        AZ_Assert(ticket.IsValid(), "Ticket provided to ClaimEntities hasn't been initialized.");
 
         ClaimEntitiesCommand queueEntry;
         queueEntry.m_ticket = &ticket;
@@ -109,6 +134,7 @@ namespace AzFramework
     void SpawnableEntitiesManager::Barrier(EntitySpawnTicket& ticket, BarrierCallback completionCallback)
     {
         AZ_Assert(completionCallback, "Barrier on spawnable entities called without a valid callback to use.");
+        AZ_Assert(ticket.IsValid(), "Ticket provided to Barrier hasn't been initialized.");
 
         BarrierCommand queueEntry;
         queueEntry.m_ticket = &ticket;
@@ -499,6 +525,27 @@ namespace AzFramework
         }
     }
 
+    bool SpawnableEntitiesManager::ProcessRequest(ListIndicesEntitiesCommand& request, [[maybe_unused]] AZ::SerializeContext& serializeContext)
+    {
+        Ticket& ticket = GetTicketPayload<Ticket>(*request.m_ticket);
+        if (request.m_ticketId == ticket.m_currentTicketId)
+        {
+            AZ_Assert(
+                ticket.m_spawnedEntities.size() == ticket.m_spawnedEntityIndices.size(),
+                "Entities and indices on spawnable ticket have gone out of sync.");
+            request.m_listCallback(
+                *request.m_ticket,
+                SpawnableConstIndexEntityContainerView(
+                    ticket.m_spawnedEntities.begin(), ticket.m_spawnedEntityIndices.begin(), ticket.m_spawnedEntities.size()));
+            ticket.m_currentTicketId++;
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
     bool SpawnableEntitiesManager::ProcessRequest(ClaimEntitiesCommand& request, [[maybe_unused]] AZ::SerializeContext& serializeContext)
     {
         Ticket& ticket = GetTicketPayload<Ticket>(*request.m_ticket);

Code/Framework/AzFramework/AzFramework/Spawnable/SpawnableEntitiesManager.h

@@ -36,6 +36,7 @@ namespace AzFramework
     {
     public:
         AZ_RTTI(AzFramework::SpawnableEntitiesManager, "{6E14333F-128C-464C-94CA-A63B05A5E51C}");
+        AZ_CLASS_ALLOCATOR(SpawnableEntitiesManager, AZ::SystemAllocator, 0);
 
         enum class CommandQueueStatus : bool
         {
@@ -58,6 +59,7 @@ namespace AzFramework
             ReloadSpawnableCallback completionCallback = {}) override;
 
         void ListEntities(EntitySpawnTicket& ticket, ListEntitiesCallback listCallback) override;
+        void ListIndicesAndEntities(EntitySpawnTicket& ticket, ListIndicesEntitiesCallback listCallback) override;
         void ClaimEntities(EntitySpawnTicket& ticket, ClaimEntitiesCallback listCallback) override;
 
         void Barrier(EntitySpawnTicket& spawnInfo, BarrierCallback completionCallback) override;
@@ -123,6 +125,12 @@ namespace AzFramework
             EntitySpawnTicket* m_ticket;
             uint32_t m_ticketId;
         };
+        struct ListIndicesEntitiesCommand
+        {
+            ListIndicesEntitiesCallback m_listCallback;
+            EntitySpawnTicket* m_ticket;
+            uint32_t m_ticketId;
+        };
         struct ClaimEntitiesCommand
         {
             ClaimEntitiesCallback m_listCallback;
@@ -141,8 +149,9 @@ namespace AzFramework
             uint32_t m_ticketId;
         };
 
-        using Requests = AZStd::variant<SpawnAllEntitiesCommand, SpawnEntitiesCommand, DespawnAllEntitiesCommand, ReloadSpawnableCommand,
-            ListEntitiesCommand, ClaimEntitiesCommand, BarrierCommand, DestroyTicketCommand>;
+        using Requests = AZStd::variant<
+            SpawnAllEntitiesCommand, SpawnEntitiesCommand, DespawnAllEntitiesCommand, ReloadSpawnableCommand, ListEntitiesCommand,
+            ListIndicesEntitiesCommand, ClaimEntitiesCommand, BarrierCommand, DestroyTicketCommand>;
 
         AZ::Entity* SpawnSingleEntity(const AZ::Entity& entityTemplate,
             AZ::SerializeContext& serializeContext);
@@ -155,6 +164,7 @@ namespace AzFramework
         bool ProcessRequest(DespawnAllEntitiesCommand& request, AZ::SerializeContext& serializeContext);
         bool ProcessRequest(ReloadSpawnableCommand& request, AZ::SerializeContext& serializeContext);
         bool ProcessRequest(ListEntitiesCommand& request, AZ::SerializeContext& serializeContext);
+        bool ProcessRequest(ListIndicesEntitiesCommand& request, AZ::SerializeContext& serializeContext);
         bool ProcessRequest(ClaimEntitiesCommand& request, AZ::SerializeContext& serializeContext);
         bool ProcessRequest(BarrierCommand& request, AZ::SerializeContext& serializeContext);
         bool ProcessRequest(DestroyTicketCommand& request, AZ::SerializeContext& serializeContext);

Code/Framework/AzFramework/AzFramework/Viewport/CameraInput.cpp

@@ -144,7 +144,7 @@ namespace AzFramework
             z = AZStd::atan2(-orientation.GetElement(1, 2), orientation.GetElement(1, 1));
         }
 
-        return {x, y, z};
+        return { x, y, z };
     }
 
     void UpdateCameraFromTransform(Camera& camera, const AZ::Transform& transform)
@@ -179,7 +179,7 @@ namespace AzFramework
     {
         const auto nextCamera = m_cameras.StepCamera(targetCamera, m_motionDelta, m_scrollDelta, deltaTime);
 
-        m_motionDelta = ScreenVector{0, 0};
+        m_motionDelta = ScreenVector{ 0, 0 };
         m_scrollDelta = 0.0f;
 
         return nextCamera;
@@ -213,7 +213,10 @@ namespace AzFramework
             auto& cameraInput = m_idleCameraInputs[i];
             const bool canBegin = cameraInput->Beginning() &&
                 AZStd::all_of(m_activeCameraInputs.cbegin(), m_activeCameraInputs.cend(),
-                              [](const auto& input) { return !input->Exclusive(); }) &&
+                              [](const auto& input)
+                              {
+                                  return !input->Exclusive();
+                              }) &&
                 (!cameraInput->Exclusive() || (cameraInput->Exclusive() && m_activeCameraInputs.empty()));
 
             if (canBegin)
@@ -231,7 +234,8 @@ namespace AzFramework
 
         const Camera nextCamera = AZStd::accumulate(
             AZStd::begin(m_activeCameraInputs), AZStd::end(m_activeCameraInputs), targetCamera,
-            [cursorDelta, scrollDelta, deltaTime](Camera acc, auto& camera) {
+            [cursorDelta, scrollDelta, deltaTime](Camera acc, auto& camera)
+            {
                 acc = camera->StepCamera(acc, cursorDelta, scrollDelta, deltaTime);
                 return acc;
             });
@@ -284,7 +288,8 @@ namespace AzFramework
 
     bool RotateCameraInput::HandleEvents(const InputEvent& event, const ScreenVector& cursorDelta, [[maybe_unused]] float scrollDelta)
     {
-        const ClickDetector::ClickEvent clickEvent = [&event, this] {
+        const ClickDetector::ClickEvent clickEvent = [&event, this]
+        {
             if (const auto& input = AZStd::get_if<DiscreteInputEvent>(&event))
             {
                 if (input->m_channelId == m_rotateChannelId)
@@ -330,7 +335,10 @@ namespace AzFramework
         nextCamera.m_pitch -= float(cursorDelta.m_y) * ed_cameraSystemRotateSpeed;
         nextCamera.m_yaw -= float(cursorDelta.m_x) * ed_cameraSystemRotateSpeed;
 
-        const auto clampRotation = [](const float angle) { return AZStd::fmod(angle + AZ::Constants::TwoPi, AZ::Constants::TwoPi); };
+        const auto clampRotation = [](const float angle)
+        {
+            return AZStd::fmod(angle + AZ::Constants::TwoPi, AZ::Constants::TwoPi);
+        };
 
         nextCamera.m_yaw = clampRotation(nextCamera.m_yaw);
         // clamp pitch to be +-90 degrees
@@ -377,9 +385,10 @@ namespace AzFramework
         const auto deltaPanX = float(cursorDelta.m_x) * panAxes.m_horizontalAxis * ed_cameraSystemPanSpeed;
         const auto deltaPanY = float(cursorDelta.m_y) * panAxes.m_verticalAxis * ed_cameraSystemPanSpeed;
 
-        const auto inv = [](const bool invert) {
-            constexpr float Dir[] = {1.0f, -1.0f};
-            return Dir[static_cast<int>(invert)];
+        const auto inv = [](const bool invert)
+        {
+            constexpr float Dir[] = { 1.0f, -1.0f };
+            return Dir[aznumeric_cast<int>(invert)];
         };
 
         nextCamera.m_lookAt += deltaPanX * inv(ed_cameraSystemPanInvertX);
@@ -475,7 +484,8 @@ namespace AzFramework
         const auto axisY = translationBasis.GetBasisY();
         const auto axisZ = translationBasis.GetBasisZ();
 
-        const float speed = [boost = m_boost]() {
+        const float speed = [boost = m_boost]()
+        {
             return ed_cameraSystemTranslateSpeed * (boost ? ed_cameraSystemBoostMultiplier : 1.0f);
         }();
 
@@ -555,10 +565,12 @@ namespace AzFramework
 
         if (Beginning())
         {
-            const auto hasLookAt = [&nextCamera, &targetCamera, &lookAtFn = m_lookAtFn] {
+            const auto hasLookAt = [&nextCamera, &targetCamera, &lookAtFn = m_lookAtFn]
+            {
                 if (lookAtFn)
                 {
-                    if (const auto lookAt = lookAtFn())
+                    // pass through the camera's position and look vector for use in the lookAt function
+                    if (const auto lookAt = lookAtFn(targetCamera.Translation(), targetCamera.Rotation().GetBasisY()))
                     {
                         auto transform = AZ::Transform::CreateLookAt(targetCamera.m_lookAt, *lookAt);
                         nextCamera.m_lookDist = -lookAt->GetDistance(targetCamera.m_lookAt);
@@ -692,14 +704,20 @@ namespace AzFramework
 
     Camera SmoothCamera(const Camera& currentCamera, const Camera& targetCamera, const float deltaTime)
     {
-        const auto clamp_rotation = [](const float angle) { return AZStd::fmod(angle + AZ::Constants::TwoPi, AZ::Constants::TwoPi); };
+        const auto clamp_rotation = [](const float angle)
+        {
+            return AZStd::fmod(angle + AZ::Constants::TwoPi, AZ::Constants::TwoPi);
+        };
 
         // keep yaw in 0 - 360 range
         float targetYaw = clamp_rotation(targetCamera.m_yaw);
         const float currentYaw = clamp_rotation(currentCamera.m_yaw);
 
         // return the sign of the float input (-1, 0, 1)
-        const auto sign = [](const float value) { return aznumeric_cast<float>((0.0f < value) - (value < 0.0f)); };
+        const auto sign = [](const float value)
+        {
+            return aznumeric_cast<float>((0.0f < value) - (value < 0.0f));
+        };
 
         // ensure smooth transition when moving across 0 - 360 boundary
         const float yawDelta = targetYaw - currentYaw;
@@ -727,26 +745,28 @@ namespace AzFramework
         const auto& inputChannelId = inputChannel.GetInputChannelId();
         const auto& inputDeviceId = inputChannel.GetInputDevice().GetInputDeviceId();
 
-        const bool wasMouseButton =
-            AZStd::any_of(InputDeviceMouse::Button::All.begin(), InputDeviceMouse::Button::All.end(), [inputChannelId](const auto& button) {
+        const bool wasMouseButton = AZStd::any_of(
+            InputDeviceMouse::Button::All.begin(), InputDeviceMouse::Button::All.end(),
+            [inputChannelId](const auto& button)
+            {
                 return button == inputChannelId;
             });
 
         if (inputChannelId == InputDeviceMouse::Movement::X)
         {
-            return HorizontalMotionEvent{(int)inputChannel.GetValue()};
+            return HorizontalMotionEvent{ aznumeric_cast<int>(inputChannel.GetValue()) };
         }
         else if (inputChannelId == InputDeviceMouse::Movement::Y)
         {
-            return VerticalMotionEvent{(int)inputChannel.GetValue()};
+            return VerticalMotionEvent{ aznumeric_cast<int>(inputChannel.GetValue()) };
         }
         else if (inputChannelId == InputDeviceMouse::Movement::Z)
         {
-            return ScrollEvent{inputChannel.GetValue()};
+            return ScrollEvent{ inputChannel.GetValue() };
         }
         else if (wasMouseButton || InputDeviceKeyboard::IsKeyboardDevice(inputDeviceId))
         {
-            return DiscreteInputEvent{inputChannelId, inputChannel.GetState()};
+            return DiscreteInputEvent{ inputChannelId, inputChannel.GetState() };
         }
 
         return AZStd::monostate{};

Code/Framework/AzFramework/AzFramework/Viewport/CameraInput.h

@@ -34,9 +34,9 @@ namespace AzFramework
         AZ::Vector3 m_lookAt = AZ::Vector3::CreateZero(); //!< Position of camera when m_lookDist is zero,
                                                           //!< or position of m_lookAt when m_lookDist is greater
                                                           //!< than zero.
-        float m_yaw{0.0};
-        float m_pitch{0.0};
-        float m_lookDist{0.0}; //!< Zero gives first person free look, otherwise orbit about m_lookAt
+        float m_yaw{ 0.0 };
+        float m_pitch{ 0.0 };
+        float m_lookDist{ 0.0 }; //!< Zero gives first person free look, otherwise orbit about m_lookAt
 
         //! View camera transform (v in MVP).
         AZ::Transform View() const;
@@ -195,7 +195,11 @@ namespace AzFramework
     inline bool Cameras::Exclusive() const
     {
         return AZStd::any_of(
-            m_activeCameraInputs.begin(), m_activeCameraInputs.end(), [](const auto& cameraInput) { return cameraInput->Exclusive(); });
+            m_activeCameraInputs.begin(), m_activeCameraInputs.end(),
+            [](const auto& cameraInput)
+            {
+                return cameraInput->Exclusive();
+            });
     }
 
     //! Responsible for updating a series of cameras given various inputs.
@@ -209,7 +213,7 @@ namespace AzFramework
 
     private:
         ScreenVector m_motionDelta; //!< The delta used for look/orbit/pan (rotation + translation) - two dimensional.
-        float m_scrollDelta = 0.0f; //!< The delta used for dolly/movement (translation) - one dimensional. 
+        float m_scrollDelta = 0.0f; //!< The delta used for dolly/movement (translation) - one dimensional.
     };
 
     class RotateCameraInput : public CameraInput
@@ -237,7 +241,7 @@ namespace AzFramework
     inline PanAxes LookPan(const Camera& camera)
     {
         const AZ::Matrix3x3 orientation = camera.Rotation();
-        return {orientation.GetBasisX(), orientation.GetBasisZ()};
+        return { orientation.GetBasisX(), orientation.GetBasisZ() };
     }
 
     inline PanAxes OrbitPan(const Camera& camera)
@@ -245,12 +249,13 @@ namespace AzFramework
         const AZ::Matrix3x3 orientation = camera.Rotation();
 
         const auto basisX = orientation.GetBasisX();
-        const auto basisY = [&orientation] {
+        const auto basisY = [&orientation]
+        {
             const auto forward = orientation.GetBasisY();
             return AZ::Vector3(forward.GetX(), forward.GetY(), 0.0f).GetNormalized();
         }();
 
-        return {basisX, basisY};
+        return { basisX, basisY };
     }
 
     class PanCameraInput : public CameraInput
@@ -285,7 +290,8 @@ namespace AzFramework
         const AZ::Matrix3x3 orientation = camera.Rotation();
 
         const auto basisX = orientation.GetBasisX();
-        const auto basisY = [&orientation] {
+        const auto basisY = [&orientation]
+        {
             const auto forward = orientation.GetBasisY();
             return AZ::Vector3(forward.GetX(), forward.GetY(), 0.0f).GetNormalized();
         }();
@@ -398,7 +404,7 @@ namespace AzFramework
     class OrbitCameraInput : public CameraInput
     {
     public:
-        using LookAtFn = AZStd::function<AZStd::optional<AZ::Vector3>()>;
+        using LookAtFn = AZStd::function<AZStd::optional<AZ::Vector3>(const AZ::Vector3& position, const AZ::Vector3& direction)>;
 
         // CameraInput overrides ...
         bool HandleEvents(const InputEvent& event, const ScreenVector& cursorDelta, float scrollDelta) override;

Code/Framework/AzFramework/AzFramework/Visibility/OctreeSystemComponent.cpp

@@ -123,8 +123,9 @@ namespace AzFramework
         OctreeNode* insertCheck = this;
         while (insertCheck != nullptr)
         {
-            if (AZ::ShapeIntersection::Contains(insertCheck->m_bounds, boundingVolume))
+            if (AZ::ShapeIntersection::Contains(insertCheck->m_bounds, boundingVolume) || !insertCheck->m_parent)
             {
+                // Insert here if the entry is fully contained or if we've reached the root node
                 return insertCheck->Insert(octreeScene, entry);
             }
             insertCheck = insertCheck->m_parent;

Code/Framework/AzManipulatorTestFramework/Include/AzManipulatorTestFramework/ViewportInteraction.h

@@ -41,6 +41,7 @@ namespace AzManipulatorTestFramework
         AZStd::optional<AZ::Vector3> ViewportScreenToWorld(const AzFramework::ScreenPoint& screenPosition, float depth) override;
         AZStd::optional<AzToolsFramework::ViewportInteraction::ProjectedViewportRay> ViewportScreenToWorldRay(
             const AzFramework::ScreenPoint& screenPosition) override;
+        float DeviceScalingFactor() override;
     private:
         // ViewportInteractionRequestBus ...
         bool GridSnappingEnabled();

Code/Framework/AzManipulatorTestFramework/Source/ViewportInteraction.cpp

@@ -127,4 +127,9 @@ namespace AzManipulatorTestFramework
     {
         return {};
     }
-} // namespace AzManipulatorTestFramework
+
+    float ViewportInteraction::DeviceScalingFactor()
+    {
+        return 1.0f;
+    }
+}// namespace AzManipulatorTestFramework

Code/Framework/AzNetworking/CMakeLists.txt

@@ -65,5 +65,12 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED)
     ly_add_googletest(
         NAME AZ::AzNetworking.Tests
     )
+
+    ly_add_googletest(
+        NAME AZ::AzNetworking.Tests.Sandbox
+        TARGET AZ::AzNetworking.Tests
+        TEST_SUITE sandbox
+    )
+    
 endif()
 

Code/Framework/AzNetworking/Tests/TcpTransport/TcpTransportTests.cpp

@@ -129,7 +129,7 @@ namespace UnitTest
     #if AZ_TRAIT_DISABLE_FAILED_NETWORKING_TESTS
     TEST_F(TcpTransportTests, DISABLED_TestSingleClient)
     #else
-    TEST_F(TcpTransportTests, TestSingleClient)
+    TEST_F(TcpTransportTests, SUITE_sandbox_TestSingleClient)
     #endif // AZ_TRAIT_DISABLE_FAILED_NETWORKING_TESTS
     {
         TestTcpServer testServer;
@@ -157,7 +157,7 @@ namespace UnitTest
     #if AZ_TRAIT_DISABLE_FAILED_NETWORKING_TESTS
     TEST_F(TcpTransportTests, DISABLED_TestMultipleClients)
     #else
-    TEST_F(TcpTransportTests, TestMultipleClients)
+    TEST_F(TcpTransportTests, SUITE_sandbox_TestMultipleClients)
     #endif // AZ_TRAIT_DISABLE_FAILED_NETWORKING_TESTS
     {
         constexpr uint32_t NumTestClients = 50;

Code/Framework/AzQtComponents/AzQtComponents/Components/img/UI20/toolbar/Local.svg

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="24px" height="24px" viewBox="0 0 24 24" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <title>Icon / Local</title>
+    <g id="Icon-/-Local" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <rect id="Rectangle" x="0" y="0" width="24" height="24"></rect>
+        <polygon id="L" fill="#FFFFFF" fill-rule="nonzero" points="16.9658203 19 16.9658203 16.5 11.1748047 16.5 11.1748047 4.72265625 8.14746094 4.72265625 8.14746094 19"></polygon>
+    </g>
+</svg>

Code/Framework/AzQtComponents/AzQtComponents/Components/img/UI20/toolbar/Parent.svg

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="24px" height="24px" viewBox="0 0 24 24" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <title>Icon / Parent</title>
+    <g id="Icon-/-Parent" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <rect id="Rectangle" x="0" y="0" width="24" height="24"></rect>
+        <path d="M10.5449219,19 L10.5449219,13.921875 L11.84375,13.921875 C13.6145833,13.921875 14.9801432,13.514974 15.9404297,12.7011719 C16.9007161,11.8873698 17.3808594,10.7122396 17.3808594,9.17578125 C17.3808594,7.69791667 16.930013,6.58626302 16.0283203,5.84082031 C15.1266276,5.0953776 13.8098958,4.72265625 12.078125,4.72265625 L12.078125,4.72265625 L7.51757812,4.72265625 L7.51757812,19 L10.5449219,19 Z M11.5410156,11.4414062 L10.5449219,11.4414062 L10.5449219,7.203125 L11.921875,7.203125 C12.7486979,7.203125 13.3557943,7.37239583 13.7431641,7.7109375 C14.1305339,8.04947917 14.3242188,8.57356771 14.3242188,9.28320312 C14.3242188,9.98632812 14.093099,10.5218099 13.6308594,10.8896484 C13.1686198,11.257487 12.4720052,11.4414062 11.5410156,11.4414062 L11.5410156,11.4414062 Z" id="P" fill="#FFFFFF" fill-rule="nonzero"></path>
+    </g>
+</svg>

Code/Framework/AzQtComponents/AzQtComponents/Components/img/UI20/toolbar/World.svg

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="24px" height="24px" viewBox="0 0 24 24" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <title>Icon / World</title>
+    <g id="Icon-/-World" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <rect id="Rectangle" x="0" y="0" width="24" height="24"></rect>
+        <path d="M9.41210938,19 L11.3359375,11.5195312 C11.4205729,11.1875 11.5410156,10.632487 11.6972656,9.85449219 C11.8535156,9.0764974 11.9511719,8.51171875 11.9902344,8.16015625 C12.016276,8.44661458 12.1155599,9.00813802 12.2880859,9.84472656 C12.460612,10.6813151 12.5826823,11.2330729 12.6542969,11.5 L12.6542969,11.5 L14.5878906,19 L18.0351562,19 L21.6679688,4.72265625 L18.6894531,4.72265625 L16.8730469,12.515625 C16.7558594,12.984375 16.625651,13.5979818 16.4824219,14.3564453 C16.3391927,15.1149089 16.235026,15.7480469 16.1699219,16.2558594 C16.0983073,15.7285156 15.9941406,15.0970052 15.8574219,14.3613281 C15.7207031,13.625651 15.6067708,13.078776 15.515625,12.7207031 L15.515625,12.7207031 L13.4355469,4.72265625 L10.5742188,4.72265625 L8.49414062,12.7207031 C8.37044271,13.1503906 8.23860677,13.7542318 8.09863281,14.5322266 C7.95865885,15.3102214 7.86914062,15.8847656 7.83007812,16.2558594 C7.68684896,15.2011719 7.45572917,13.9544271 7.13671875,12.515625 L7.13671875,12.515625 L5.31054688,4.72265625 L2.33203125,4.72265625 L5.97460938,19 L9.41210938,19 Z" id="W" fill="#FFFFFF" fill-rule="nonzero"></path>
+    </g>
+</svg>

Code/Framework/AzQtComponents/AzQtComponents/Components/resources.qrc

@@ -354,6 +354,7 @@
     <file>img/UI20/toolbar/Grid.svg</file>
     <file>img/UI20/toolbar/Lighting.svg</file>
     <file>img/UI20/toolbar/Load.svg</file>
+	<file>img/UI20/toolbar/Local.svg</file>
     <file>img/UI20/toolbar/Locked.svg</file>
     <file>img/UI20/toolbar/LUA.svg</file>
     <file>img/UI20/toolbar/Material.svg</file>
@@ -362,6 +363,7 @@
     <file>img/UI20/toolbar/Object_follow_terrain.svg</file>
     <file>img/UI20/toolbar/Object_height.svg</file>
     <file>img/UI20/toolbar/Object_list.svg</file>
+	<file>img/UI20/toolbar/Parent.svg</file>
     <file>img/UI20/toolbar/particle.svg</file>
     <file>img/UI20/toolbar/Play.svg</file>
     <file>img/UI20/toolbar/Redo.svg</file>
@@ -380,6 +382,7 @@
     <file>img/UI20/toolbar/undo.svg</file>
     <file>img/UI20/toolbar/Unlocked.svg</file>
     <file>img/UI20/toolbar/Vertex_snapping.svg</file>
+	<file>img/UI20/toolbar/World.svg</file>
     <file>img/UI20/toolbar/X_axis.svg</file>
     <file>img/UI20/toolbar/Y_axis.svg</file>
     <file>img/UI20/toolbar/Z_axis.svg</file>

Code/Framework/AzTest/AzTest/Platform/Linux/AzTest_Traits_Linux.h

@@ -39,4 +39,3 @@
 #define AZ_TRAIT_DISABLE_FAILED_EMOTION_FX_EDITOR_TESTS true
 #define AZ_TRAIT_DISABLE_FAILED_METRICS_TESTS true
 
-#define AZ_TRAIT_DISABLE_ASSET_JOB_PARALLEL_TESTS true

Code/Framework/AzToolsFramework/AzToolsFramework/API/EditorAssetSystemAPI.h

@@ -60,10 +60,20 @@ namespace AzToolsFramework
             //! and is generally checked into source control.
             virtual const char* GetAbsoluteDevRootFolderPath() = 0;
         
-            /// Convert a full source path like "c:\\dev\gamename\\blah\\test.tga" into a relative product path.
+            /// Convert a full source path like "c:\\dev\\gamename\\blah\\test.tga" into a relative product path.
             /// asset paths never mention their alias and are relative to the asset cache root
             virtual bool GetRelativeProductPathFromFullSourceOrProductPath(const AZStd::string& fullPath, AZStd::string& relativeProductPath) = 0;
 
+            /** Convert a source path like "c:\\dev\\gamename\\blah\\test.tga" into a relative source path, like "blah/test.tga".
+            * If no valid relative path could be created, the input source path will be returned in relativePath.
+            * @param sourcePath partial or full path to a source file.  (The file doesn't need to exist)
+            * @param relativePath the output relative path for the source file, if a valid one could be created
+            * @param rootFilePath the root path that relativePath is relative to
+            * @return true if a valid relative path was created, false if it wasn't
+            */
+            virtual bool GenerateRelativeSourcePath(
+                const AZStd::string& sourcePath, AZStd::string& relativePath, AZStd::string& rootFilePath) = 0;
+
             /// Convert a relative asset path like "blah/test.tga" to a full source path path.
             /// Once the asset processor has finished building, this function is capable of handling even when the extension changes
             /// or when the source is in a different folder or in a different location (such as inside gems)
@@ -110,14 +120,14 @@ namespace AzToolsFramework
 
             /**
             * Query to see if a specific asset platform is enabled
-            * @param platform the asset platform to check e.g. es3, ios, etc.
+            * @param platform the asset platform to check e.g. android, ios, etc.
             * @return true if enabled, false otherwise
             */
             virtual bool IsAssetPlatformEnabled(const char* platform) = 0;
 
             /**
             * Get the total number of pending assets left to process for a specific asset platform
-            * @param platform the asset platform to check e.g. es3, ios, etc.
+            * @param platform the asset platform to check e.g. android, ios, etc.
             * @return -1 if the process fails, a positive number otherwise
             */
             virtual int GetPendingAssetsForPlatform(const char* platform) = 0;
@@ -302,7 +312,7 @@ namespace AzToolsFramework
         inline const char* GetHostAssetPlatform()
         {
 #if defined(AZ_PLATFORM_MAC)
-            return "osx_gl";
+            return "mac";
 #elif defined(AZ_PLATFORM_WINDOWS)
             return "pc";
 #elif defined(AZ_PLATFORM_LINUX)

Code/Framework/AzToolsFramework/AzToolsFramework/API/EditorViewportIconDisplayInterface.h

@@ -0,0 +1,80 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+#pragma once
+
+#include <AzCore/RTTI/RTTI.h>
+#include <AzCore/Interface/Interface.h>
+#include <AzCore/Math/Color.h>
+
+#include <AzFramework/Viewport/ViewportId.h>
+
+namespace AzToolsFramework
+{
+    //! An interface for loading simple icon assets and rendering them to screen on a per-viewport basis.
+    class EditorViewportIconDisplayInterface
+    {
+    public:
+        AZ_RTTI(EditorViewportIconDisplayInterface, "{D5190B58-2561-4F3F-B793-F1E7D454CDF2}");
+
+        using IconId = AZ::s32;
+        static constexpr IconId InvalidIconId = -1;
+
+        enum class CoordinateSpace : AZ::u8
+        {
+            ScreenSpace,
+            WorldSpace
+        };
+
+        //! These draw parameters control rendering for a single icon to a single viewport.
+        struct DrawParameters
+        {
+            //! The ViewportId to render to.
+            AzFramework::ViewportId m_viewport = AzFramework::InvalidViewportId;
+            //! The icon ID, retrieved from GetOrLoadIconForPath, to render to screen.
+            IconId m_icon = InvalidIconId;
+            //! The color, including opacity, to render the icon with. White will render the icon as opaque in its original color.
+            AZ::Color m_color = AZ::Colors::White;
+            //! The position to render the icon to, in world or screen space depending on m_positionSpace.
+            AZ::Vector3 m_position;
+            //! The coordinate system to use for m_position.
+            //! ScreenSpace will accept m_position in the form of [X, Y, Depth], where X & Y are screen coordinates in
+            //! pixels and Depth is a z-ordering depth value from 0.0f to 1.0f.
+            //! WorldSpace will accept a 3D vector in world space coordinates that will be translated back into screen
+            //! space when the icon is rendered.
+            CoordinateSpace m_positionSpace = CoordinateSpace::ScreenSpace;
+            //! The size to render the icon as, in pixels.
+            AZ::Vector2 m_size;
+        };
+
+        //! The current load status of an icon retrieved by GetOrLoadIconForPath.
+        enum class IconLoadStatus : AZ::u8
+        {
+            Unloaded,
+            Loading,
+            Loaded,
+            Error
+        };
+
+        //! Draws an icon to a viewport given a set of draw parameters.
+        //! Requires an IconId retrieved from GetOrLoadIconForPath.
+        virtual void DrawIcon(const DrawParameters& drawParameters) = 0;
+        //! Retrieves a reusable IconId for an icon at a given path.
+        //! This will load the icon, if it has not already been loaded.
+        //! @param path should be a relative asset path to an icon image asset.
+        //! png and svg icons are currently supported.
+        virtual IconId GetOrLoadIconForPath(AZStd::string_view path) = 0;
+        //! Gets the current load status of an icon retrieved via GetOrLoadIconForPath.
+        virtual IconLoadStatus GetIconLoadStatus(IconId icon) = 0;
+    };
+
+    using EditorViewportIconDisplay = AZ::Interface<EditorViewportIconDisplayInterface>;
+} //namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/API/ToolsApplicationAPI.h

@@ -239,6 +239,11 @@ namespace AzToolsFramework
         */
         virtual int RemoveDirtyEntity(AZ::EntityId target) = 0;
 
+        /*!
+         * Clears the dirty entity set.
+         */
+        virtual void ClearDirtyEntities() = 0;
+
         /*!
          * \return true if an undo/redo operation is in progress.
          */

Code/Framework/AzToolsFramework/AzToolsFramework/Application/ToolsApplication.cpp

@@ -1354,6 +1354,11 @@ namespace AzToolsFramework
         return static_cast<int>(m_dirtyEntities.erase(entityId));
     }
 
+    void ToolsApplication::ClearDirtyEntities()
+    {
+        m_dirtyEntities.clear();
+    }
+
     void ToolsApplication::UndoPressed()
     {
         if (m_undoStack)

Code/Framework/AzToolsFramework/AzToolsFramework/Application/ToolsApplication.h

@@ -85,6 +85,7 @@ namespace AzToolsFramework
 
         void AddDirtyEntity(AZ::EntityId entityId) override;
         int RemoveDirtyEntity(AZ::EntityId entityId) override;
+        void ClearDirtyEntities() override;
         bool IsDuringUndoRedo() override { return m_isDuringUndoRedo; }
         void UndoPressed() override;
         void RedoPressed() override;

Code/Framework/AzToolsFramework/AzToolsFramework/Asset/AssetSystemComponent.cpp

@@ -265,6 +265,30 @@ namespace AzToolsFramework
             return response.m_resolved;
         }
 
+        bool AssetSystemComponent::GenerateRelativeSourcePath(
+            const AZStd::string& sourcePath, AZStd::string& relativePath, AZStd::string& rootFilePath)
+        {
+            AzFramework::SocketConnection* engineConnection = AzFramework::SocketConnection::GetInstance();
+            if (!engineConnection || !engineConnection->IsConnected())
+            {
+                relativePath = sourcePath;
+                return false;
+            }
+
+            AzFramework::AssetSystem::GenerateRelativeSourcePathRequest request(sourcePath);
+            AzFramework::AssetSystem::GenerateRelativeSourcePathResponse response;
+            if (!SendRequest(request, response))
+            {
+                AZ_Error("Editor", false, "Failed to send GenerateRelativeSourcePath request for %s", sourcePath.c_str());
+                relativePath = sourcePath;
+                return false;
+            }
+
+            relativePath = response.m_relativeSourcePath;
+            rootFilePath = response.m_rootFolder;
+            return response.m_resolved;
+        }
+
         bool AssetSystemComponent::GetFullSourcePathFromRelativeProductPath(const AZStd::string& relPath, AZStd::string& fullPath)
         {
             auto foundIt = m_assetSourceRelativePathToFullPathCache.find(relPath);

Code/Framework/AzToolsFramework/AzToolsFramework/Asset/AssetSystemComponent.h

@@ -63,6 +63,8 @@ namespace AzToolsFramework
             const char* GetAbsoluteDevGameFolderPath() override;
             const char* GetAbsoluteDevRootFolderPath() override;
             bool GetRelativeProductPathFromFullSourceOrProductPath(const AZStd::string& fullPath, AZStd::string& outputPath) override;
+            bool GenerateRelativeSourcePath(
+                const AZStd::string& sourcePath, AZStd::string& outputPath, AZStd::string& watchFolder) override;
             bool GetFullSourcePathFromRelativeProductPath(const AZStd::string& relPath, AZStd::string& fullPath) override;
             bool GetAssetInfoById(const AZ::Data::AssetId& assetId, const AZ::Data::AssetType& assetType, const AZStd::string& platformName, AZ::Data::AssetInfo& assetInfo, AZStd::string& rootFilePath) override;
             bool GetSourceInfoBySourcePath(const char* sourcePath, AZ::Data::AssetInfo& assetInfo, AZStd::string& watchFolder) override;

Code/Framework/AzToolsFramework/AzToolsFramework/AssetBrowser/AssetPicker/AssetPickerDialog.cpp

@@ -81,9 +81,20 @@ namespace AzToolsFramework
 
             m_ui->m_assetBrowserTreeViewWidget->SetName("AssetBrowserTreeView_" + name);
 
+            bool selectedAsset = false;
+
             for (auto& assetId : selection.GetSelectedAssetIds())
             {
-                m_ui->m_assetBrowserTreeViewWidget->SelectProduct(assetId);
+                if (assetId.IsValid())
+                {
+                    selectedAsset = true;
+                    m_ui->m_assetBrowserTreeViewWidget->SelectProduct(assetId);
+                }
+            }
+
+            if (!selectedAsset)
+            {
+                m_ui->m_assetBrowserTreeViewWidget->SelectFolder(selection.GetDefaultDirectory());
             }
 
             setWindowTitle(tr("Pick %1").arg(m_selection.GetTitle()));

Code/Framework/AzToolsFramework/AzToolsFramework/AssetBrowser/AssetSelectionModel.cpp

@@ -93,6 +93,16 @@ namespace AzToolsFramework
             m_selectedAssetIds.push_back(selectedAssetId);
         }
 
+        void AssetSelectionModel::SetDefaultDirectory(AZStd::string_view defaultDirectory)
+        {
+            m_defaultDirectory = defaultDirectory;
+        }
+
+        AZStd::string_view AssetSelectionModel::GetDefaultDirectory() const
+        {
+            return m_defaultDirectory;
+        }
+
         AZStd::vector<const AssetBrowserEntry*>& AssetSelectionModel::GetResults()
         {
             return m_results;

Code/Framework/AzToolsFramework/AzToolsFramework/AssetBrowser/AssetSelectionModel.h

@@ -47,6 +47,9 @@ namespace AzToolsFramework
             const AZStd::vector<AZ::Data::AssetId>& GetSelectedAssetIds() const;
             void SetSelectedAssetIds(const AZStd::vector<AZ::Data::AssetId>& selectedAssetIds);
             void SetSelectedAssetId(const AZ::Data::AssetId& selectedAssetId);
+
+            void SetDefaultDirectory(AZStd::string_view defaultDirectory);
+            AZStd::string_view GetDefaultDirectory() const;
             
             AZStd::vector<const AssetBrowserEntry*>& GetResults();
             const AssetBrowserEntry* GetResult();
@@ -72,6 +75,7 @@ namespace AzToolsFramework
             
             AZStd::vector<AZ::Data::AssetId> m_selectedAssetIds;
             AZStd::vector<const AssetBrowserEntry*> m_results;
+            AZStd::string m_defaultDirectory;
 
             QString m_title;
         };

Code/Framework/AzToolsFramework/AzToolsFramework/AssetBrowser/Views/AssetBrowserTreeView.cpp

@@ -14,6 +14,7 @@
 #include <AzCore/Asset/AssetManagerBus.h>
 #include <AzCore/Math/Crc.h>
 #include <AzCore/std/containers/vector.h>
+#include <AzCore/StringFunc/StringFunc.h>
 
 #include <AzFramework/StringFunc/StringFunc.h>
 
@@ -270,7 +271,20 @@ namespace AzToolsFramework
             return false;
         }
 
-        bool AssetBrowserTreeView::SelectEntry(const QModelIndex& idxParent, const AZStd::vector<AZStd::string>& entries, const uint32_t entryPathIndex)
+        void AssetBrowserTreeView::SelectFolder(AZStd::string_view folderPath)
+        {
+            if (folderPath.size() == 0)
+            {
+                return;
+            }
+
+            AZStd::vector<AZStd::string> entries;
+            AZ::StringFunc::Tokenize(folderPath, entries, "/");
+
+            SelectEntry(QModelIndex(), entries, 0, true);
+        }
+
+        bool AssetBrowserTreeView::SelectEntry(const QModelIndex& idxParent, const AZStd::vector<AZStd::string>& entries, const uint32_t entryPathIndex, bool useDisplayName)
         {
             if (entries.empty())
             {
@@ -285,30 +299,43 @@ namespace AzToolsFramework
                 auto rowIdx = model()->index(idx, 0, idxParent);
                 auto rowEntry = GetEntryFromIndex<AssetBrowserEntry>(rowIdx);
 
-                // Check if this entry name matches the query
-                if (rowEntry && AzFramework::StringFunc::Equal(entry.c_str(), rowEntry->GetName().c_str(), true))
+                if (rowEntry)
                 {
-                    // Final entry found - set it as the selected element
-                    if (entryPathIndex == entries.size() - 1)
-                    {
-                        selectionModel()->clear();
-                        selectionModel()->select(rowIdx, QItemSelectionModel::Select);
-                        setCurrentIndex(rowIdx);
-                        return true;
-                    }
+                    // Check if this entry name matches the query
+                    AZStd::string_view compareName = useDisplayName ? (const char*)(rowEntry->GetDisplayName().toUtf8()) : rowEntry->GetName().c_str();
 
-                    // If this isn't the final entry, it needs to be a folder for the path to be valid (otherwise, early out)
-                    if (rowEntry->GetEntryType() == AssetBrowserEntry::AssetEntryType::Folder)
+                    if (AzFramework::StringFunc::Equal(entry.c_str(), compareName, true))
                     {
-                        // Folder found - if the final entry is found, expand this folder so the final entry is viewable in the Asset Browser (otherwise, early out)
-                        if (SelectEntry(rowIdx, entries, entryPathIndex + 1))
+                        // Final entry found - set it as the selected element
+                        if (entryPathIndex == entries.size() - 1)
                         {
-                            expand(rowIdx);
+                            if (rowEntry->GetEntryType() == AssetBrowserEntry::AssetEntryType::Folder)
+                            {
+                                // Expand the item itself if it is a folder
+                                expand(rowIdx);
+                            }
+
+                            selectionModel()->clear();
+                            selectionModel()->select(rowIdx, QItemSelectionModel::Select);
+                            setCurrentIndex(rowIdx);
+
                             return true;
                         }
+
+                        // If this isn't the final entry, it needs to be a folder for the path to be valid (otherwise, early out)
+                        if (rowEntry->GetEntryType() == AssetBrowserEntry::AssetEntryType::Folder)
+                        {
+                            // Folder found - if the final entry is found, expand this folder so the final entry is viewable in the Asset
+                            // Browser (otherwise, early out)
+                            if (SelectEntry(rowIdx, entries, entryPathIndex + 1, useDisplayName))
+                            {
+                                expand(rowIdx);
+                                return true;
+                            }
+                        }
+
+                        return false;
                     }
-                    
-                    return false;
                 }
             }
 

Code/Framework/AzToolsFramework/AzToolsFramework/AssetBrowser/Views/AssetBrowserTreeView.h

@@ -60,6 +60,8 @@ namespace AzToolsFramework
 
             AZStd::vector<AssetBrowserEntry*> GetSelectedAssets() const;
 
+            void SelectFolder(AZStd::string_view folderPath);
+
             //////////////////////////////////////////////////////////////////////////
             // AssetBrowserViewRequestBus
             void SelectProduct(AZ::Data::AssetId assetID) override;
@@ -67,6 +69,7 @@ namespace AzToolsFramework
             void ClearFilter() override;
 
             void Update() override;
+
             //////////////////////////////////////////////////////////////////////////
 
             //////////////////////////////////////////////////////////////////////////
@@ -105,7 +108,7 @@ namespace AzToolsFramework
             QString m_name;
 
             bool SelectProduct(const QModelIndex& idxParent, AZ::Data::AssetId assetID);
-            bool SelectEntry(const QModelIndex& idxParent, const AZStd::vector<AZStd::string>& entryPathTokens, const uint32_t entryPathIndex = 0);
+            bool SelectEntry(const QModelIndex& idxParent, const AZStd::vector<AZStd::string>& entryPathTokens, const uint32_t entryPathIndex = 0, bool useDisplayName = false);
 
             //! Grab one entry from the source thumbnail list and update it
             void UpdateSCThumbnails();

Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipInterface.h

@@ -56,5 +56,7 @@ namespace AzToolsFramework
         
         virtual void StartPlayInEditor() = 0;
         virtual void StopPlayInEditor() = 0;
+
+        virtual void CreateNewLevelPrefab(AZStd::string_view filename, const AZStd::string& templateFilename) = 0;
     };
 }

Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipService.cpp

@@ -14,9 +14,11 @@
 #include <AzCore/Component/TransformBus.h>
 #include <AzCore/Script/ScriptSystemBus.h>
 #include <AzCore/Serialization/Utils.h>
+#include <AzCore/StringFunc/StringFunc.h>
 #include <AzFramework/API/ApplicationAPI.h>
 #include <AzFramework/Entity/GameEntityContextBus.h>
 #include <AzFramework/Spawnable/RootSpawnableInterface.h>
+#include <AzToolsFramework/API/EditorAssetSystemAPI.h>
 #include <AzToolsFramework/API/ToolsApplicationAPI.h>
 #include <AzToolsFramework/Entity/PrefabEditorEntityOwnershipService.h>
 #include <AzToolsFramework/Prefab/EditorPrefabComponent.h>
@@ -55,7 +57,6 @@ namespace AzToolsFramework
             "Couldn't get prefab loader interface, it's a requirement for PrefabEntityOwnership system to work");
 
         m_rootInstance = AZStd::unique_ptr<Prefab::Instance>(m_prefabSystemComponent->CreatePrefab({}, {}, "NewLevel.prefab"));
-
         m_sliceOwnershipService.BusConnect(m_entityContextId);
         m_sliceOwnershipService.m_shouldAssertForLegacySlicesUsage = m_shouldAssertForLegacySlicesUsage;
         m_editorSliceOwnershipService.BusConnect();
@@ -89,14 +90,17 @@ namespace AzToolsFramework
 
     void PrefabEditorEntityOwnershipService::Reset()
     {
-        Prefab::TemplateId templateId = m_rootInstance->GetTemplateId();
-        if (templateId != Prefab::InvalidTemplateId)
+        if (m_rootInstance)
         {
-            m_rootInstance->SetTemplateId(Prefab::InvalidTemplateId);
-            m_prefabSystemComponent->RemoveTemplate(templateId);
+            Prefab::TemplateId templateId = m_rootInstance->GetTemplateId();
+            if (templateId != Prefab::InvalidTemplateId)
+            {
+                m_rootInstance->SetTemplateId(Prefab::InvalidTemplateId);
+                m_prefabSystemComponent->RemoveTemplate(templateId);
+            }
+            m_rootInstance->Reset();
+            m_rootInstance->SetContainerEntityName("Level");
         }
-        m_rootInstance->Reset();
-        m_rootInstance->SetContainerEntityName("Level");
 
         AzFramework::EntityOwnershipServiceNotificationBus::Event(
             m_entityContextId, &AzFramework::EntityOwnershipServiceNotificationBus::Events::OnEntityOwnershipServiceReset);
@@ -200,7 +204,7 @@ namespace AzToolsFramework
         }
 
         m_rootInstance->SetTemplateId(templateId);
-        m_rootInstance->SetTemplateSourcePath(m_loaderInterface->GetRelativePathToProject(filename));
+        m_rootInstance->SetTemplateSourcePath(m_loaderInterface->GenerateRelativePath(filename));
         m_rootInstance->SetContainerEntityName("Level");
         m_prefabSystemComponent->PropagateTemplateChanges(templateId);
 
@@ -218,16 +222,15 @@ namespace AzToolsFramework
 
     bool PrefabEditorEntityOwnershipService::SaveToStream(AZ::IO::GenericStream& stream, AZStd::string_view filename)
     {
-        AZ::IO::Path relativePath = m_loaderInterface->GetRelativePathToProject(filename);
+        AZ::IO::Path relativePath = m_loaderInterface->GenerateRelativePath(filename);
         AzToolsFramework::Prefab::TemplateId templateId = m_prefabSystemComponent->GetTemplateIdFromFilePath(relativePath);
 
         m_rootInstance->SetTemplateSourcePath(relativePath);
+
         if (templateId == AzToolsFramework::Prefab::InvalidTemplateId)
         {
-            // This has not been loaded yet, this is the case of being saved with a different name.
-            // Create it
             m_rootInstance->m_containerEntity->AddComponent(aznew Prefab::EditorPrefabComponent());
-            HandleEntitiesAdded({m_rootInstance->m_containerEntity.get()});
+            HandleEntitiesAdded({ m_rootInstance->m_containerEntity.get() });
 
             AzToolsFramework::Prefab::PrefabDom dom;
             bool success = AzToolsFramework::Prefab::PrefabDomUtils::StoreInstanceInPrefabDom(*m_rootInstance, dom);
@@ -236,7 +239,8 @@ namespace AzToolsFramework
                 AZ_Error("Prefab", false, "Failed to convert current root instance into a DOM when saving file '%.*s'", AZ_STRING_ARG(filename));
                 return false;
             }
-            templateId = m_prefabSystemComponent->AddTemplate(relativePath, std::move(dom));
+            templateId = m_prefabSystemComponent->AddTemplate(relativePath, AZStd::move(dom));
+
             if (templateId == AzToolsFramework::Prefab::InvalidTemplateId)
             {
                 AZ_Error("Prefab", false, "Couldn't add new template id '%i' when saving file '%.*s'", templateId, AZ_STRING_ARG(filename));
@@ -263,6 +267,71 @@ namespace AzToolsFramework
         return false;
     }
 
+    void PrefabEditorEntityOwnershipService::CreateNewLevelPrefab(AZStd::string_view filename, const AZStd::string& templateFilename)
+    {
+        AZ::IO::Path relativePath = m_loaderInterface->GenerateRelativePath(filename);
+        AzToolsFramework::Prefab::TemplateId templateId = m_prefabSystemComponent->GetTemplateIdFromFilePath(relativePath);
+
+        m_rootInstance->SetTemplateSourcePath(relativePath);
+
+        AZStd::string watchFolder;
+        AZ::Data::AssetInfo assetInfo;
+        bool sourceInfoFound = false;
+        AzToolsFramework::AssetSystemRequestBus::BroadcastResult(
+            sourceInfoFound, &AzToolsFramework::AssetSystemRequestBus::Events::GetSourceInfoBySourcePath, templateFilename.c_str(),
+            assetInfo, watchFolder);
+
+        if (sourceInfoFound)
+        {
+            AZStd::string fullPath;
+            AZ::StringFunc::Path::Join(watchFolder.c_str(), assetInfo.m_relativePath.c_str(), fullPath);
+
+            // Get the default prefab and copy the Dom over to the new template being saved
+            Prefab::TemplateId defaultId = m_loaderInterface->LoadTemplateFromFile(fullPath.c_str());
+            Prefab::PrefabDom& dom = m_prefabSystemComponent->FindTemplateDom(defaultId);
+
+            Prefab::PrefabDom levelDefaultDom;
+            levelDefaultDom.CopyFrom(dom, levelDefaultDom.GetAllocator());
+
+            Prefab::PrefabDomPath sourcePath("/Source");
+            sourcePath.Set(levelDefaultDom, relativePath.c_str());
+
+            templateId = m_prefabSystemComponent->AddTemplate(relativePath, AZStd::move(levelDefaultDom));
+        }
+        else
+        {
+            m_rootInstance->m_containerEntity->AddComponent(aznew Prefab::EditorPrefabComponent());
+            HandleEntitiesAdded({ m_rootInstance->m_containerEntity.get() });
+
+            AzToolsFramework::Prefab::PrefabDom dom;
+            bool success = AzToolsFramework::Prefab::PrefabDomUtils::StoreInstanceInPrefabDom(*m_rootInstance, dom);
+            if (!success)
+            {
+                AZ_Error(
+                    "Prefab", false, "Failed to convert current root instance into a DOM when saving file '%.*s'", AZ_STRING_ARG(filename));
+                return;
+            }
+            templateId = m_prefabSystemComponent->AddTemplate(relativePath, std::move(dom));
+        }
+
+        if (templateId == AzToolsFramework::Prefab::InvalidTemplateId)
+        {
+            AZ_Error("Prefab", false, "Couldn't create new template id '%i' when creating new level '%.*s'", templateId, AZ_STRING_ARG(filename));
+            return;
+        }
+
+        Prefab::TemplateId prevTemplateId = m_rootInstance->GetTemplateId();
+        m_rootInstance->SetTemplateId(templateId);
+
+        if (prevTemplateId != Prefab::InvalidTemplateId && templateId != prevTemplateId)
+        {
+            // Make sure we only have one level template loaded at a time
+            m_prefabSystemComponent->RemoveTemplate(prevTemplateId);
+        }
+
+        m_prefabSystemComponent->PropagateTemplateChanges(templateId);
+    }
+
     Prefab::InstanceOptionalReference PrefabEditorEntityOwnershipService::CreatePrefab(
         const AZStd::vector<AZ::Entity*>& entities, AZStd::vector<AZStd::unique_ptr<Prefab::Instance>>&& nestedPrefabInstances,
         AZ::IO::PathView filePath, Prefab::InstanceOptionalReference instanceToParentUnder)
@@ -311,7 +380,12 @@ namespace AzToolsFramework
     Prefab::InstanceOptionalReference PrefabEditorEntityOwnershipService::GetRootPrefabInstance()
     {
         AZ_Assert(m_rootInstance, "A valid root prefab instance couldn't be found in PrefabEditorEntityOwnershipService.");
-        return *m_rootInstance;
+        if (m_rootInstance)
+        {
+            return *m_rootInstance;
+        }
+
+        return AZStd::nullopt;
     }
 
     const AZStd::vector<AZ::Data::Asset<AZ::Data::AssetData>>& PrefabEditorEntityOwnershipService::GetPlayInEditorAssetData()

Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipService.h

@@ -170,6 +170,8 @@ namespace AzToolsFramework
         void StartPlayInEditor() override;
         void StopPlayInEditor() override;
 
+        void CreateNewLevelPrefab(AZStd::string_view filename, const AZStd::string& templateFilename) override;
+
     protected:
 
         AZ::SliceComponent::SliceInstanceAddress GetOwningSlice() override;

Code/Framework/AzToolsFramework/AzToolsFramework/Entity/SliceEditorEntityOwnershipService.cpp

@@ -614,7 +614,7 @@ namespace AzToolsFramework
 
                                     AZ::Quaternion oldEntityRotation;
                                     AZ::TransformBus::EventResult(oldEntityRotation, id, &AZ::TransformBus::Events::GetWorldRotationQuaternion);
-                                    transformComponent->SetRotationQuaternion(oldEntityRotation);
+                                    transformComponent->SetWorldRotationQuaternion(oldEntityRotation);
 
                                     // Ensure the existing hierarchy is maintained
                                     AZ::EntityId oldParentEntityId;

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/LineSegmentSelectionManipulator.cpp

@@ -31,7 +31,7 @@ namespace AzToolsFramework
             rayProportion, lineSegmentProportion, worldClosestPositionRay, worldClosestPositionLineSegment);
 
         AZ::Transform worldFromLocalNormalized = worldFromLocal;
-        const AZ::Vector3 scale = worldFromLocalNormalized.ExtractScale() * nonUniformScale;
+        const AZ::Vector3 scale = worldFromLocalNormalized.ExtractUniformScale() * nonUniformScale;
         const AZ::Transform localFromWorldNormalized = worldFromLocalNormalized.GetInverse();
 
         return { (localFromWorldNormalized.TransformPoint(worldClosestPositionLineSegment)) / scale };

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/LinearManipulator.cpp

@@ -59,7 +59,7 @@ namespace AzToolsFramework
             ? CalculateSnappedOffset(localTransform.GetTranslation(), axis, gridSize * scaleRecip)
             : AZ::Vector3::CreateZero();
 
-        const AZ::Vector3 localScale = localTransform.GetScale();
+        const AZ::Vector3 localScale = AZ::Vector3(localTransform.GetUniformScale());
         const AZ::Quaternion localRotation = QuaternionFromTransformNoScaling(localTransform);
         // calculate scale amount to snap, to align to round scale value
         const AZ::Vector3 scaleSnapOffset = snapping && !gridSnapAction.m_localSnapping

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ManipulatorSnapping.h

@@ -113,7 +113,7 @@ namespace AzToolsFramework
     /// noise in the value returned when dealing with values far from the origin.
     inline float ScaleReciprocal(const AZ::Transform& transform)
     {
-        return Round3(transform.GetScale().GetReciprocal().GetMinElement());
+        return Round3(1.0f / transform.GetUniformScale());
     }
 
     /// Find the reciprocal of the non-uniform scale.

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ManipulatorSpace.cpp

@@ -39,7 +39,7 @@ namespace AzToolsFramework
         AZ::Transform result;
         result.SetRotation(m_space.GetRotation() * localTransform.GetRotation());
         result.SetTranslation(m_space.TransformPoint(m_nonUniformScale * localTransform.GetTranslation()));
-        result.SetScale(m_space.GetScale() * localTransform.GetScale());
+        result.SetScale(m_space.GetScale() * localTransform.GetUniformScale());
         return result;
     }
 

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ManipulatorView.cpp

@@ -447,17 +447,14 @@ namespace AzToolsFramework
                 m_radius * viewScale);
 
         debugDisplay.SetColor(ViewColor(manipulatorState.m_mouseOver, m_color, m_mouseOverColor).GetAsVector4());
-
-        // show wireframe if the axis has been corrected/flipped
-        //   note: please see IRenderAuxGeom.h for the definition of e_FillModeWireframe and e_FillModeSolid.
-        //   it is not possible to include IRenderAuxGeom from here and we also don't want to introduce that dependency.
-        //   these legacy enums should be wrapped so set SetFillMode can be used in a type safe way, until then,
-        //   use the values directly until the API has been updated.
-        const AZ::u32 prevFillMode = debugDisplay.SetFillMode(
-            m_shouldCorrect ? /*e_FillModeWireframe =*/ 0x1 << 26 : /*e_FillModeSolid =*/ 0);
-
-        debugDisplay.DrawCone(coneBound.m_base, coneBound.m_axis, coneBound.m_radius, coneBound.m_height, false);
-        debugDisplay.SetFillMode(prevFillMode);
+        if (m_shouldCorrect)
+        {
+            debugDisplay.DrawWireCone(coneBound.m_base, coneBound.m_axis, coneBound.m_radius, coneBound.m_height);
+        }
+        else
+        {
+            debugDisplay.DrawSolidCone(coneBound.m_base, coneBound.m_axis, coneBound.m_radius, coneBound.m_height, false);
+        }
 
         RefreshBoundInternal(managerId, manipulatorId, coneBound);
     }

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ScaleManipulators.cpp

@@ -82,9 +82,7 @@ namespace AzToolsFramework
 
         m_uniformScaleManipulator->SetVisualOrientationOverride(
             QuaternionFromTransformNoScaling(localTransform));
-        m_uniformScaleManipulator->SetLocalTransform(
-            AZ::Transform::CreateTranslation(localTransform.GetTranslation()) *
-            AZ::Transform::CreateScale(localTransform.GetScale()));
+        m_uniformScaleManipulator->SetLocalOrientation(AZ::Quaternion::CreateIdentity());
     }
 
     void ScaleManipulators::SetLocalPositionImpl(const AZ::Vector3& localPosition)

Code/Framework/AzToolsFramework/AzToolsFramework/Maths/TransformUtils.h

@@ -23,7 +23,7 @@ namespace AzToolsFramework
     inline AZ::Transform TransformNormalizedScale(const AZ::Transform& transform)
     {
         AZ::Transform transformNormalizedScale = transform;
-        transformNormalizedScale.SetScale(AZ::Vector3::CreateOne());
+        transformNormalizedScale.SetUniformScale(1.0f);
         return transformNormalizedScale;
     }
 
@@ -33,8 +33,7 @@ namespace AzToolsFramework
     inline AZ::Transform TransformUniformScale(const AZ::Transform& transform)
     {
         AZ::Transform transformUniformScale = transform;
-        const float maxScale = transformUniformScale.GetScale().GetMaxElement();
-        transformUniformScale.SetScale(AZ::Vector3(maxScale));
+        transformUniformScale.SetUniformScale(transformUniformScale.GetUniformScale());
         return transformUniformScale;
     }
 

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Instance/InstanceSerializer.cpp

@@ -124,7 +124,7 @@ namespace AzToolsFramework
                         "PrefabLoaderInterface could not be found. It is required to load Prefab Instances");
 
                     // Make sure we have a relative path
-                    instance->m_templateSourcePath = loaderInterface->GetRelativePathToProject(instance->m_templateSourcePath);
+                    instance->m_templateSourcePath = loaderInterface->GenerateRelativePath(instance->m_templateSourcePath);
 
                     TemplateId templateId = prefabSystemComponentInterface->GetTemplateIdFromFilePath(instance->GetTemplateSourcePath());
 

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Instance/InstanceToTemplatePropagator.cpp

@@ -276,18 +276,14 @@ namespace AzToolsFramework
             PrefabDomValueReference linkPatchesReference =
                 PrefabDomUtils::FindPrefabDomValue(linkDom, PrefabDomUtils::PatchesName);
 
-            // This logic only covers addition of patches. If patches already exists, the given list of patches must be appended to them.
-            if (!linkPatchesReference.has_value())
-            {
-                /*
-                If the original allocator the patches were created with gets destroyed, then the patches would become garbage in the
-                linkDom. Since we cannot guarantee the lifecycle of the patch allocators, we are doing a copy of the patches here to
-                associate them with the linkDom's allocator.
-                */
-                PrefabDom patchesCopy;
-                patchesCopy.CopyFrom(patches, linkDom.GetAllocator());
-                linkDom.AddMember(rapidjson::StringRef(PrefabDomUtils::PatchesName), patchesCopy, linkDom.GetAllocator());
-            }
+            /*
+            If the original allocator the patches were created with gets destroyed, then the patches would become garbage in the
+            linkDom. Since we cannot guarantee the lifecycle of the patch allocators, we are doing a copy of the patches here to
+            associate them with the linkDom's allocator.
+            */
+            PrefabDom patchesCopy;
+            patchesCopy.CopyFrom(patches, linkDom.GetAllocator());
+            linkDom.AddMember(rapidjson::StringRef(PrefabDomUtils::PatchesName), patchesCopy, linkDom.GetAllocator());
         }
     }
 }

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Link/Link.cpp

@@ -234,5 +234,10 @@ namespace AzToolsFramework
             }
         }
 
+        PrefabDomValueReference Link::GetLinkPatches()
+        {
+            return PrefabDomUtils::FindPrefabDomValue(m_linkDom, PrefabDomUtils::PatchesName);
+        }
+
     } // namespace Prefab
 } // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Link/Link.h

@@ -79,6 +79,8 @@ namespace AzToolsFramework
              */
             void AddLinkIdToInstanceDom(PrefabDomValue& instanceDomValue);
 
+            PrefabDomValueReference GetLinkPatches();
+
         private:
 
             /**