Merge branch 'main' of https://github.com/aws-lumberyard/o3de into Spawnable/ScriptCanvas/Integration

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

@@ -287,71 +287,28 @@ namespace AZ
 
         //! Scale modifiers
         //! @{
-        //! @deprecated Use SetLocalScale()
-        //! Scales the entity along the world's axes. The origin of the axes is the entity's position in the world.
-        //! @param scale A three-dimensional vector that represents the multipliers with which to scale the entity in world space.
-        virtual void SetScale([[maybe_unused]] const AZ::Vector3& scale) {}
-
-        //! @deprecated Use SetLocalScaleX()
-        //! Scales the entity along the world's X axis. The origin of the axis is the entity's position in the world.
-        //! @param scaleX The multiplier by which to scale the entity along the X axis in world space.
-        virtual void SetScaleX([[maybe_unused]] float scaleX) {}
-
-        //! @deprecated Use SetLocalScaleY()
-        //! Scales the entity along the world's Y axis. The origin of the axis is the entity's position in the world.
-        //! @param scaleY The multiplier by which to scale the entity along the Y axis in world space.
-        virtual void SetScaleY([[maybe_unused]] float scaleY) {}
-
-        //! @deprecated Use SetLocalScaleZ()
-        //! Scales the entity along the world's Z axis. The origin of the axis is the entity's position in the world.
-        //! @param scaleZ The multiplier by which to scale the entity along the Z axis in world space.
-        virtual void SetScaleZ([[maybe_unused]] float scaleZ) {}
-
-        //! @deprecated Use GetLocalScale()
-        //! Gets the scale of the entity in world space.
-        //! @return A three-dimensional vector that represents the scale of the entity in world space.
-        virtual AZ::Vector3 GetScale() { return AZ::Vector3(FLT_MAX); }
-
-        //! @deprecated Use GetLocalScale()
-        //! Gets the amount by which an entity is scaled along the world's X axis.
-        //! @return The amount by which an entity is scaled along the X axis in world space.
-        virtual float GetScaleX() { return FLT_MAX; }
-
-        //! @deprecated Use GetLocalScale()
-        //! Gets the amount by which an entity is scaled along the world's Y axis.
-        //! @return The amount by which an entity is scaled along the Y axis in world space.
-        virtual float GetScaleY() { return FLT_MAX; }
-
-        //! @deprecated Use GetLocalScale()
-        //! Gets the amount by which an entity is scaled along the world's Z axis.
-        //! @return The amount by which an entity is scaled along the Z axis in world space.
-        virtual float GetScaleZ() { return FLT_MAX; }
-
         //! Set local scale of the transform.
-        //! @param scale The new scale to set along three local axes.
+        //! @param scale The new scale to set.
         virtual void SetLocalScale([[maybe_unused]] const AZ::Vector3& scale) {}
 
-        //! Set local scale of the transform on x-axis.
-        //! @param scaleX The new x-axis scale to set.
-        virtual void SetLocalScaleX([[maybe_unused]] float scaleX) {}
-
-        //! Set local scale of the transform on y-axis.
-        //! @param scaleY The new y-axis scale to set.
-        virtual void SetLocalScaleY([[maybe_unused]] float scaleY) {}
-
-        //! Set local scale of the transform on z-axis.
-        //! @param scaleZ The new z-axis scale to set.
-        virtual void SetLocalScaleZ([[maybe_unused]] float scaleZ) {}
-
-        //! Get the scale value on each axis in local space
-        //! @return The scale value of type Vector3 along each axis in local space.
+        //! Get the scale value in local space.
+        //! @return The scale value in local space.
         virtual AZ::Vector3 GetLocalScale() { return AZ::Vector3(FLT_MAX); }
 
-        //! Get the scale value on each axis in world space.
-        //! Note the transform will be skewed when it is rotated and has a parent transform scaled, in which
-        //! case the returned world-scale from this function will be inaccurate.
-        //! @return The scale value of type Vector3 along each axis in world space.
+        //! Get the scale value in world space.
+        //! @return The scale value in world space.
         virtual AZ::Vector3 GetWorldScale() { return AZ::Vector3(FLT_MAX); }
+
+        //! Set the uniform scale value in local space.
+        virtual void SetLocalUniformScale([[maybe_unused]] float scale) {}
+
+        //! Get the uniform scale value in local space.
+        //! @return The uniform scale value in local space.
+        virtual float GetLocalUniformScale() { return FLT_MAX; }
+
+        //! Get the uniform scale value in world space.
+        //! @return The uniform scale value in world space.
+        virtual float GetWorldUniformScale() { return FLT_MAX; }
         //! @}
 
         //! Transform hierarchy

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/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/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);