diff --git a/Code/Editor/Lib/Tests/test_DisplaySettingsPythonBindings.cpp b/Code/Editor/Lib/Tests/test_DisplaySettingsPythonBindings.cpp
index fd65634d4e..b73cb039ea 100644
--- a/Code/Editor/Lib/Tests/test_DisplaySettingsPythonBindings.cpp
+++ b/Code/Editor/Lib/Tests/test_DisplaySettingsPythonBindings.cpp
@@ -35,6 +35,11 @@ namespace DisplaySettingsPythonBindingsUnitTests
 
             m_app.Start(appDesc);
             m_app.RegisterComponentDescriptor(AzToolsFramework::DisplaySettingsPythonFuncsHandler::CreateDescriptor());
+
+            // Without this, the user settings component would attempt to save on finalize/shutdown. Since the file is
+            // shared across the whole engine, if multiple tests are run in parallel, the saving could cause a crash
+            // in the unit tests.
+            AZ::UserSettingsComponentRequestBus::Broadcast(&AZ::UserSettingsComponentRequests::DisableSaveOnFinalize);
         }
 
         void TearDown() override
diff --git a/Code/Framework/AzCore/AzCore/std/string/fixed_string.inl b/Code/Framework/AzCore/AzCore/std/string/fixed_string.inl
index 15d2acf7a1..a1c95b7ba2 100644
--- a/Code/Framework/AzCore/AzCore/std/string/fixed_string.inl
+++ b/Code/Framework/AzCore/AzCore/std/string/fixed_string.inl
@@ -1760,7 +1760,8 @@ namespace AZStd
     template<class Element, size_t MaxElementCount, class Traits>
     struct hash<basic_fixed_string<Element, MaxElementCount, Traits>>
     {
-        inline constexpr size_t operator()(const basic_fixed_string<Element, MaxElementCount, Traits>& value) const
+        using is_transparent = void;
+        inline constexpr size_t operator()(const basic_string_view<Element, Traits>& value) const
         {
             return hash_string(value.begin(), value.length());
         }
diff --git a/Code/Framework/AzCore/AzCore/std/string/string.h b/Code/Framework/AzCore/AzCore/std/string/string.h
index 7dd6dd7065..56afd16226 100644
--- a/Code/Framework/AzCore/AzCore/std/string/string.h
+++ b/Code/Framework/AzCore/AzCore/std/string/string.h
@@ -2071,9 +2071,8 @@ namespace AZStd
     template<class Element, class Traits, class Allocator>
     struct hash< basic_string< Element, Traits, Allocator> >
     {
-        typedef basic_string< Element, Traits, Allocator> argument_type;
-        typedef AZStd::size_t                           result_type;
-        inline result_type operator()(const argument_type& value) const
+        using is_transparent = void;
+        inline constexpr size_t operator()(const basic_string_view<Element, Traits>& value) const
         {
             return hash_string(value.begin(), value.length());
         }
diff --git a/Code/Legacy/CryCommon/IMovieSystem.h b/Code/Legacy/CryCommon/IMovieSystem.h
index 79c000bfca..a55d764afa 100644
--- a/Code/Legacy/CryCommon/IMovieSystem.h
+++ b/Code/Legacy/CryCommon/IMovieSystem.h
@@ -13,7 +13,6 @@
 #include <AzCore/Math/Crc.h>
 #include <AzCore/Math/Quaternion.h>
 #include <AzCore/Serialization/SerializeContext.h>
-#include <AzCore/std/allocator_stateless.h>
 
 #include <Range.h>
 #include <AnimKey.h>
@@ -184,7 +183,7 @@ public:
 
 private:
     AnimParamType m_type;
-    AZStd::basic_string<char, AZStd::char_traits<char>, AZStd::stateless_allocator> m_name;
+    AZStd::string m_name;
 };
 
 namespace AZStd
@@ -620,7 +619,7 @@ public:
             , valueType(_valueType)
             , flags(_flags) {};
 
-        AZStd::basic_string<char, AZStd::char_traits<char>, AZStd::stateless_allocator> name;           // parameter name.
+        AZStd::string name;           // parameter name.
         CAnimParamType paramType;     // parameter id.
         AnimValueType valueType;       // value type, defines type of track to use for animating this parameter.
         ESupportedParamFlags flags; // combination of flags from ESupportedParamFlags.
diff --git a/Gems/GraphCanvas/Code/StaticLib/GraphCanvas/Styling/SelectorImplementations.h b/Gems/GraphCanvas/Code/StaticLib/GraphCanvas/Styling/SelectorImplementations.h
index 1c65bf1915..eac9abdec8 100644
--- a/Gems/GraphCanvas/Code/StaticLib/GraphCanvas/Styling/SelectorImplementations.h
+++ b/Gems/GraphCanvas/Code/StaticLib/GraphCanvas/Styling/SelectorImplementations.h
@@ -79,7 +79,7 @@ namespace GraphCanvas
 
         private:
             AZStd::string m_value;
-            AZStd::hash<AZStd::string>::result_type m_hash;
+            size_t m_hash;
 
             friend class BasicSelectorEventHandler;
         };
diff --git a/Gems/LyShine/Code/Source/Animation/AnimNode.h b/Gems/LyShine/Code/Source/Animation/AnimNode.h
index 4d139e99ca..0076276204 100644
--- a/Gems/LyShine/Code/Source/Animation/AnimNode.h
+++ b/Gems/LyShine/Code/Source/Animation/AnimNode.h
@@ -13,7 +13,6 @@
 
 #include <LyShine/Animation/IUiAnimation.h>
 #include "UiAnimationSystem.h"
-#include <AzCore/std/allocator_stateless.h>
 
 
 /*!
@@ -40,7 +39,7 @@ public:
             , valueType(_valueType)
             , flags(_flags) {};
 
-        AZStd::basic_string<char, AZStd::char_traits<char>, AZStd::stateless_allocator> name;               // parameter name.
+        AZStd::string name;               // parameter name.
         CUiAnimParamType paramType;     // parameter id.
         EUiAnimValue valueType;         // value type, defines type of track to use for animating this parameter.
         ESupportedParamFlags flags;     // combination of flags from ESupportedParamFlags.
diff --git a/Gems/LyShine/Code/Source/Animation/UiAnimationSystem.cpp b/Gems/LyShine/Code/Source/Animation/UiAnimationSystem.cpp
index c8818836d6..06e7110fe2 100644
--- a/Gems/LyShine/Code/Source/Animation/UiAnimationSystem.cpp
+++ b/Gems/LyShine/Code/Source/Animation/UiAnimationSystem.cpp
@@ -14,77 +14,59 @@
 #include "UiAnimSerialize.h"
 
 #include <AzCore/Component/ComponentApplicationBus.h>
-#include <AzCore/std/allocator_stateless.h>
 #include <AzCore/std/containers/map.h>
 #include <AzCore/std/containers/unordered_map.h>
-#include <StlUtils.h>
 
 #include <ISystem.h>
 #include <ILog.h>
 #include <IConsole.h>
 
 //////////////////////////////////////////////////////////////////////////
-namespace
-{
-    using UiAnimParamSystemString = AZStd::basic_string<char, AZStd::char_traits<char>, AZStd::stateless_allocator>;
 
-    template <typename KeyType, typename MappedType, typename Compare = AZStd::less<KeyType>>
-    using UiAnimSystemOrderedMap = AZStd::map<KeyType, MappedType, Compare, AZStd::stateless_allocator>;
-    template <typename KeyType, typename MappedType, typename Hasher = AZStd::hash<KeyType>, typename EqualKey = AZStd::equal_to<KeyType>>
-    using UiAnimSystemUnorderedMap = AZStd::unordered_map<KeyType, MappedType, Hasher, EqualKey, AZStd::stateless_allocator>;
-}
 // Serialization for anim nodes & param types
-#define REGISTER_NODE_TYPE(name) assert(!g_animNodeEnumToStringMap.contains(eUiAnimNodeType_ ## name)); \
-    g_animNodeEnumToStringMap[eUiAnimNodeType_ ## name] = AZ_STRINGIZE(name);                                                            \
-    g_animNodeStringToEnumMap[UiAnimParamSystemString(AZ_STRINGIZE(name))] = eUiAnimNodeType_ ## name;
+#define REGISTER_NODE_TYPE(name) assert(!m_animNodeEnumToStringMap.contains(eUiAnimNodeType_ ## name)); \
+    m_animNodeEnumToStringMap[eUiAnimNodeType_ ## name] = AZ_STRINGIZE(name);                                                            \
+    m_animNodeStringToEnumMap[UiAnimParamSystemString(AZ_STRINGIZE(name))] = eUiAnimNodeType_ ## name;
 
-#define REGISTER_PARAM_TYPE(name) assert(!g_animParamEnumToStringMap.contains(eUiAnimParamType_ ## name)); \
-    g_animParamEnumToStringMap[eUiAnimParamType_ ## name] = AZ_STRINGIZE(name);                                                              \
-    g_animParamStringToEnumMap[UiAnimParamSystemString(AZ_STRINGIZE(name))] = eUiAnimParamType_ ## name;
+#define REGISTER_PARAM_TYPE(name) assert(!m_animParamEnumToStringMap.contains(eUiAnimParamType_ ## name)); \
+    m_animParamEnumToStringMap[eUiAnimParamType_ ## name] = AZ_STRINGIZE(name);                                                              \
+    m_animParamStringToEnumMap[UiAnimParamSystemString(AZ_STRINGIZE(name))] = eUiAnimParamType_ ## name;
 
-namespace
+
+// If you get an assert in this function, it means two node types have the same enum value.
+void UiAnimationSystem::RegisterNodeTypes()
 {
-    UiAnimSystemUnorderedMap<int, UiAnimParamSystemString> g_animNodeEnumToStringMap;
-    UiAnimSystemOrderedMap<UiAnimParamSystemString, EUiAnimNodeType, stl::less_stricmp<UiAnimParamSystemString>> g_animNodeStringToEnumMap;
+    REGISTER_NODE_TYPE(Entity)
+    REGISTER_NODE_TYPE(Director)
+    REGISTER_NODE_TYPE(Camera)
+    REGISTER_NODE_TYPE(CVar)
+    REGISTER_NODE_TYPE(ScriptVar)
+    REGISTER_NODE_TYPE(Material)
+    REGISTER_NODE_TYPE(Event)
+    REGISTER_NODE_TYPE(Group)
+    REGISTER_NODE_TYPE(Layer)
+    REGISTER_NODE_TYPE(Comment)
+    REGISTER_NODE_TYPE(RadialBlur)
+    REGISTER_NODE_TYPE(ColorCorrection)
+    REGISTER_NODE_TYPE(DepthOfField)
+    REGISTER_NODE_TYPE(ScreenFader)
+    REGISTER_NODE_TYPE(Light)
+    REGISTER_NODE_TYPE(HDRSetup)
+    REGISTER_NODE_TYPE(ShadowSetup)
+    REGISTER_NODE_TYPE(Alembic)
+    REGISTER_NODE_TYPE(GeomCache)
+    REGISTER_NODE_TYPE(Environment)
+    REGISTER_NODE_TYPE(ScreenDropsSetup)
+    REGISTER_NODE_TYPE(AzEntity)
+}
 
-    UiAnimSystemUnorderedMap<int, UiAnimParamSystemString> g_animParamEnumToStringMap;
-    UiAnimSystemOrderedMap<UiAnimParamSystemString, EUiAnimParamType, stl::less_stricmp<UiAnimParamSystemString>> g_animParamStringToEnumMap;
-
-    // If you get an assert in this function, it means two node types have the same enum value.
-    void RegisterNodeTypes()
-    {
-        REGISTER_NODE_TYPE(Entity)
-        REGISTER_NODE_TYPE(Director)
-        REGISTER_NODE_TYPE(Camera)
-        REGISTER_NODE_TYPE(CVar)
-        REGISTER_NODE_TYPE(ScriptVar)
-        REGISTER_NODE_TYPE(Material)
-        REGISTER_NODE_TYPE(Event)
-        REGISTER_NODE_TYPE(Group)
-        REGISTER_NODE_TYPE(Layer)
-        REGISTER_NODE_TYPE(Comment)
-        REGISTER_NODE_TYPE(RadialBlur)
-        REGISTER_NODE_TYPE(ColorCorrection)
-        REGISTER_NODE_TYPE(DepthOfField)
-        REGISTER_NODE_TYPE(ScreenFader)
-        REGISTER_NODE_TYPE(Light)
-        REGISTER_NODE_TYPE(HDRSetup)
-        REGISTER_NODE_TYPE(ShadowSetup)
-        REGISTER_NODE_TYPE(Alembic)
-        REGISTER_NODE_TYPE(GeomCache)
-        REGISTER_NODE_TYPE(Environment)
-        REGISTER_NODE_TYPE(ScreenDropsSetup)
-        REGISTER_NODE_TYPE(AzEntity)
-    }
-
-    // If you get an assert in this function, it means two param types have the same enum value.
-    void RegisterParamTypes()
-    {
-        REGISTER_PARAM_TYPE(Event)
-        REGISTER_PARAM_TYPE(Float)
-        REGISTER_PARAM_TYPE(TrackEvent)
-        REGISTER_PARAM_TYPE(AzComponentField)
-    }
+// If you get an assert in this function, it means two param types have the same enum value.
+void UiAnimationSystem::RegisterParamTypes()
+{
+    REGISTER_PARAM_TYPE(Event)
+    REGISTER_PARAM_TYPE(Float)
+    REGISTER_PARAM_TYPE(TrackEvent)
+    REGISTER_PARAM_TYPE(AzComponentField)
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -98,6 +80,10 @@ UiAnimationSystem::UiAnimationSystem()
     m_lastUpdateTime = AZ::Time::ZeroTimeUs;
 
     m_nextSequenceId = 1;
+
+    DoNodeStaticInitialisation();
+    RegisterNodeTypes();
+    RegisterParamTypes();
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -1173,16 +1159,16 @@ void UiAnimationSystem::SerializeNodeType(EUiAnimNodeType& animNodeType, XmlNode
             XmlString nodeTypeString;
             if (xmlNode->getAttr(kType, nodeTypeString))
             {
-                assert(g_animNodeStringToEnumMap.find(nodeTypeString.c_str()) != g_animNodeStringToEnumMap.end());
-                animNodeType = stl::find_in_map(g_animNodeStringToEnumMap, nodeTypeString.c_str(), eUiAnimNodeType_Invalid);
+                assert(m_animNodeStringToEnumMap.contains(nodeTypeString.c_str()));
+                animNodeType = stl::find_in_map(m_animNodeStringToEnumMap, nodeTypeString.c_str(), eUiAnimNodeType_Invalid);
             }
         }
     }
     else
     {
         const char* pTypeString = "Invalid";
-        assert(g_animNodeEnumToStringMap.find(animNodeType) != g_animNodeEnumToStringMap.end());
-        pTypeString = g_animNodeEnumToStringMap[animNodeType].c_str();
+        assert(m_animNodeEnumToStringMap.find(animNodeType) != m_animNodeEnumToStringMap.end());
+        pTypeString = m_animNodeEnumToStringMap[animNodeType].c_str();
         xmlNode->setAttr(kType, pTypeString);
     }
 }
@@ -1242,8 +1228,8 @@ void UiAnimationSystem::SerializeParamType(CUiAnimParamType& animParamType, XmlN
                 }
                 else
                 {
-                    assert(g_animParamStringToEnumMap.find(paramTypeString.c_str()) != g_animParamStringToEnumMap.end());
-                    animParamType.m_type = stl::find_in_map(g_animParamStringToEnumMap, paramTypeString.c_str(), eUiAnimParamType_Invalid);
+                    assert(m_animParamStringToEnumMap.contains(paramTypeString.c_str()));
+                    animParamType.m_type = stl::find_in_map(m_animParamStringToEnumMap, paramTypeString.c_str(), eUiAnimParamType_Invalid);
                 }
             }
         }
@@ -1265,8 +1251,8 @@ void UiAnimationSystem::SerializeParamType(CUiAnimParamType& animParamType, XmlN
         }
         else
         {
-            assert(g_animParamEnumToStringMap.find(animParamType.m_type) != g_animParamEnumToStringMap.end());
-            pTypeString = g_animParamEnumToStringMap[animParamType.m_type].c_str();
+            assert(m_animParamEnumToStringMap.find(animParamType.m_type) != m_animParamEnumToStringMap.end());
+            pTypeString = m_animParamEnumToStringMap[animParamType.m_type].c_str();
         }
 
         xmlNode->setAttr(kParamType, pTypeString);
@@ -1332,9 +1318,9 @@ const char* UiAnimationSystem::GetParamTypeName(const CUiAnimParamType& animPara
     }
     else
     {
-        if (g_animParamEnumToStringMap.find(animParamType.m_type) != g_animParamEnumToStringMap.end())
+        if (m_animParamEnumToStringMap.find(animParamType.m_type) != m_animParamEnumToStringMap.end())
         {
-            return g_animParamEnumToStringMap[animParamType.m_type].c_str();
+            return m_animParamEnumToStringMap[animParamType.m_type].c_str();
         }
     }
 
@@ -1346,15 +1332,6 @@ void UiAnimationSystem::OnCameraCut()
 {
 }
 
-//////////////////////////////////////////////////////////////////////////
-void UiAnimationSystem::StaticInitialize()
-{
-    DoNodeStaticInitialisation();
-
-    RegisterNodeTypes();
-    RegisterParamTypes();
-}
-
 //////////////////////////////////////////////////////////////////////////
 void UiAnimationSystem::Reflect(AZ::SerializeContext* serializeContext)
 {
@@ -1380,13 +1357,13 @@ void UiAnimationSystem::Reflect(AZ::SerializeContext* serializeContext)
 //////////////////////////////////////////////////////////////////////////
 EUiAnimNodeType UiAnimationSystem::GetNodeTypeFromString(const char* pString) const
 {
-    return stl::find_in_map(g_animNodeStringToEnumMap, pString, eUiAnimNodeType_Invalid);
+    return stl::find_in_map(m_animNodeStringToEnumMap, pString, eUiAnimNodeType_Invalid);
 }
 
 //////////////////////////////////////////////////////////////////////////
 CUiAnimParamType UiAnimationSystem::GetParamTypeFromString(const char* pString) const
 {
-    const EUiAnimParamType paramType = stl::find_in_map(g_animParamStringToEnumMap, pString, eUiAnimParamType_Invalid);
+    const EUiAnimParamType paramType = stl::find_in_map(m_animParamStringToEnumMap, pString, eUiAnimParamType_Invalid);
 
     if (paramType != eUiAnimParamType_Invalid)
     {
diff --git a/Gems/LyShine/Code/Source/Animation/UiAnimationSystem.h b/Gems/LyShine/Code/Source/Animation/UiAnimationSystem.h
index cd51cd51d0..6c710205fa 100644
--- a/Gems/LyShine/Code/Source/Animation/UiAnimationSystem.h
+++ b/Gems/LyShine/Code/Source/Animation/UiAnimationSystem.h
@@ -14,6 +14,8 @@
 #include <AzCore/std/containers/map.h>
 #include <AzCore/Time/ITime.h>
 
+#include <CryCommon/StlUtils.h>
+
 struct PlayingUIAnimSequence
 {
     //! Sequence playing
@@ -134,12 +136,10 @@ public:
     void SerializeParamType(CUiAnimParamType& animParamType, XmlNodeRef& xmlNode, bool bLoading, const uint version) override;
     void SerializeParamData(UiAnimParamData& animParamData, XmlNodeRef& xmlNode, bool bLoading) override;
 
-    static const char* GetParamTypeName(const CUiAnimParamType& animParamType);
+    const char* GetParamTypeName(const CUiAnimParamType& animParamType);
 
     void OnCameraCut();
 
-    static void StaticInitialize();
-
     static void Reflect(AZ::SerializeContext* serializeContext);
 
     void NotifyTrackEventListeners(const char* eventName, const char* valueName, IUiAnimSequence* pSequence) override;
@@ -187,5 +187,21 @@ private:
     // A sequence which turned on the early animation update last time
     uint32 m_nextSequenceId;
 
+
+    using UiAnimParamSystemString = AZStd::string;
+    template <typename KeyType, typename MappedType, typename Compare = stl::less_stricmp<KeyType>>
+    using UiAnimSystemOrderedMap = AZStd::map<KeyType, MappedType, Compare>;
+    template <typename KeyType, typename MappedType, typename Hasher = AZStd::hash<KeyType>, typename EqualKey = AZStd::equal_to<>>
+    using UiAnimSystemUnorderedMap = AZStd::unordered_map<KeyType, MappedType, Hasher, EqualKey>;
+
+    UiAnimSystemUnorderedMap<int, UiAnimParamSystemString> m_animNodeEnumToStringMap;
+    UiAnimSystemOrderedMap<UiAnimParamSystemString, EUiAnimNodeType> m_animNodeStringToEnumMap;
+
+    UiAnimSystemUnorderedMap<int, UiAnimParamSystemString> m_animParamEnumToStringMap;
+    UiAnimSystemOrderedMap<UiAnimParamSystemString, EUiAnimParamType> m_animParamStringToEnumMap;
+
+    void RegisterNodeTypes();
+    void RegisterParamTypes();
+
     void ShowPlayedSequencesDebug();
 };
diff --git a/Gems/LyShine/Code/Source/LyShine.cpp b/Gems/LyShine/Code/Source/LyShine.cpp
index 5a704329ef..b362ed2106 100644
--- a/Gems/LyShine/Code/Source/LyShine.cpp
+++ b/Gems/LyShine/Code/Source/LyShine.cpp
@@ -156,8 +156,6 @@ CLyShine::CLyShine([[maybe_unused]] ISystem* system)
     UiElementComponent::Initialize();
     UiCanvasComponent::Initialize();
 
-    UiAnimationSystem::StaticInitialize();
-
     AzFramework::InputChannelEventListener::Connect();
     AzFramework::InputTextEventListener::Connect();
     UiCursorBus::Handler::BusConnect();
diff --git a/Gems/Maestro/Code/Source/Cinematics/AnimPostFXNode.cpp b/Gems/Maestro/Code/Source/Cinematics/AnimPostFXNode.cpp
index b535033351..7e32301b71 100644
--- a/Gems/Maestro/Code/Source/Cinematics/AnimPostFXNode.cpp
+++ b/Gems/Maestro/Code/Source/Cinematics/AnimPostFXNode.cpp
@@ -8,7 +8,6 @@
 
 
 #include <AzCore/Serialization/SerializeContext.h>
-#include <AzCore/std/allocator_stateless.h>
 #include "AnimPostFXNode.h"
 #include "AnimSplineTrack.h"
 #include "CompoundSplineTrack.h"
@@ -39,7 +38,7 @@ public:
         virtual void GetDefault(bool& val) const = 0;
         virtual void GetDefault(Vec4& val) const = 0;
 
-        AZStd::basic_string<char, AZStd::char_traits<char>, AZStd::stateless_allocator> m_name;
+        AZStd::string m_name;
 
     protected:
         virtual ~CControlParamBase(){}
diff --git a/Gems/Maestro/Code/Source/Cinematics/Movie.cpp b/Gems/Maestro/Code/Source/Cinematics/Movie.cpp
index dc0782f982..51be8a4c24 100644
--- a/Gems/Maestro/Code/Source/Cinematics/Movie.cpp
+++ b/Gems/Maestro/Code/Source/Cinematics/Movie.cpp
@@ -7,7 +7,6 @@
  */
 
 #include <AzCore/Component/Entity.h>
-#include <AzCore/std/allocator_stateless.h>
 #include <AzCore/std/containers/map.h>
 #include <AzCore/std/containers/unordered_map.h>
 #include <AzCore/Time/ITime.h>
@@ -28,7 +27,6 @@
 #include "LayerNode.h"
 #include "ShadowsSetupNode.h"
 
-#include <StlUtils.h>
 #include <MathConversion.h>
 #include <StaticInstance.h>
 
@@ -74,136 +72,117 @@ static SMovieSequenceAutoComplete s_movieSequenceAutoComplete;
 #endif
 
 //////////////////////////////////////////////////////////////////////////
-namespace
-{
-    using AnimParamSystemString = AZStd::basic_string<char, AZStd::char_traits<char>, AZStd::stateless_allocator>;
+// Serialization for anim nodes & param types
+#define REGISTER_NODE_TYPE(name) assert(!m_animNodeEnumToStringMap.contains(AnimNodeType::name)); \
+    m_animNodeEnumToStringMap[AnimNodeType::name] = AZ_STRINGIZE(name);                          \
+    m_animNodeStringToEnumMap[AnimParamSystemString(AZ_STRINGIZE(name))] = AnimNodeType::name;
 
-    template <typename KeyType, typename MappedType, typename Compare = AZStd::less<KeyType>>
-    using AnimSystemOrderedMap = AZStd::map<KeyType, MappedType, Compare, AZStd::stateless_allocator>;
-    template <typename KeyType, typename MappedType, typename Hasher = AZStd::hash<KeyType>, typename EqualKey = AZStd::equal_to<KeyType>>
-    using AnimSystemUnorderedMap = AZStd::unordered_map<KeyType, MappedType, Hasher, EqualKey, AZStd::stateless_allocator>;
+#define REGISTER_PARAM_TYPE(name) assert(!m_animParamEnumToStringMap.contains(AnimParamType::name)); \
+    m_animParamEnumToStringMap[AnimParamType::name] = AZ_STRINGIZE(name);                           \
+    m_animParamStringToEnumMap[AnimParamSystemString(AZ_STRINGIZE(name))] = AnimParamType::name;
+
+// If you get an assert in this function, it means two node types have the same enum value.
+void CMovieSystem::RegisterNodeTypes()
+{
+    REGISTER_NODE_TYPE(Entity)
+    REGISTER_NODE_TYPE(Director)
+    REGISTER_NODE_TYPE(Camera)
+    REGISTER_NODE_TYPE(CVar)
+    REGISTER_NODE_TYPE(ScriptVar)
+    REGISTER_NODE_TYPE(Material)
+    REGISTER_NODE_TYPE(Event)
+    REGISTER_NODE_TYPE(Group)
+    REGISTER_NODE_TYPE(Layer)
+    REGISTER_NODE_TYPE(Comment)
+    REGISTER_NODE_TYPE(RadialBlur)
+    REGISTER_NODE_TYPE(ColorCorrection)
+    REGISTER_NODE_TYPE(DepthOfField)
+    REGISTER_NODE_TYPE(ScreenFader)
+    REGISTER_NODE_TYPE(Light)
+    REGISTER_NODE_TYPE(ShadowSetup)
+    REGISTER_NODE_TYPE(Alembic)
+    REGISTER_NODE_TYPE(GeomCache)
+    REGISTER_NODE_TYPE(Environment)
+    REGISTER_NODE_TYPE(AzEntity)
+    REGISTER_NODE_TYPE(Component)
 }
 
-// Serialization for anim nodes & param types
-#define REGISTER_NODE_TYPE(name) assert(!g_animNodeEnumToStringMap.contains(AnimNodeType::name)); \
-    g_animNodeEnumToStringMap[AnimNodeType::name] = AZ_STRINGIZE(name);                          \
-    g_animNodeStringToEnumMap[AnimParamSystemString(AZ_STRINGIZE(name))] = AnimNodeType::name;
-
-#define REGISTER_PARAM_TYPE(name) assert(!g_animParamEnumToStringMap.contains(AnimParamType::name)); \
-    g_animParamEnumToStringMap[AnimParamType::name] = AZ_STRINGIZE(name);                           \
-    g_animParamStringToEnumMap[AnimParamSystemString(AZ_STRINGIZE(name))] = AnimParamType::name;
-
-namespace
+// If you get an assert in this function, it means two param types have the same enum value.
+void CMovieSystem::RegisterParamTypes()
 {
-    AnimSystemUnorderedMap<AnimNodeType, AnimParamSystemString> g_animNodeEnumToStringMap;
-    AnimSystemOrderedMap<AnimParamSystemString, AnimNodeType, stl::less_stricmp<AnimParamSystemString>> g_animNodeStringToEnumMap;
-
-    AnimSystemUnorderedMap<AnimParamType, AnimParamSystemString> g_animParamEnumToStringMap;
-    AnimSystemOrderedMap<AnimParamSystemString, AnimParamType, stl::less_stricmp<AnimParamSystemString>> g_animParamStringToEnumMap;
-
-    // If you get an assert in this function, it means two node types have the same enum value.
-    void RegisterNodeTypes()
-    {
-        REGISTER_NODE_TYPE(Entity)
-        REGISTER_NODE_TYPE(Director)
-        REGISTER_NODE_TYPE(Camera)
-        REGISTER_NODE_TYPE(CVar)
-        REGISTER_NODE_TYPE(ScriptVar)
-        REGISTER_NODE_TYPE(Material)
-        REGISTER_NODE_TYPE(Event)
-        REGISTER_NODE_TYPE(Group)
-        REGISTER_NODE_TYPE(Layer)
-        REGISTER_NODE_TYPE(Comment)
-        REGISTER_NODE_TYPE(RadialBlur)
-        REGISTER_NODE_TYPE(ColorCorrection)
-        REGISTER_NODE_TYPE(DepthOfField)
-        REGISTER_NODE_TYPE(ScreenFader)
-        REGISTER_NODE_TYPE(Light)
-        REGISTER_NODE_TYPE(ShadowSetup)
-        REGISTER_NODE_TYPE(Alembic)
-        REGISTER_NODE_TYPE(GeomCache)
-        REGISTER_NODE_TYPE(Environment)
-        REGISTER_NODE_TYPE(AzEntity)
-        REGISTER_NODE_TYPE(Component)
-    }
-
-    // If you get an assert in this function, it means two param types have the same enum value.
-    void RegisterParamTypes()
-    {
-        REGISTER_PARAM_TYPE(FOV)
-        REGISTER_PARAM_TYPE(Position)
-        REGISTER_PARAM_TYPE(Rotation)
-        REGISTER_PARAM_TYPE(Scale)
-        REGISTER_PARAM_TYPE(Event)
-        REGISTER_PARAM_TYPE(Visibility)
-        REGISTER_PARAM_TYPE(Camera)
-        REGISTER_PARAM_TYPE(Animation)
-        REGISTER_PARAM_TYPE(Sound)
-        REGISTER_PARAM_TYPE(Sequence)
-        REGISTER_PARAM_TYPE(Console)
-        REGISTER_PARAM_TYPE(Music)                      ///@deprecated in 1.11, left in for legacy serialization
-        REGISTER_PARAM_TYPE(Float)
-        REGISTER_PARAM_TYPE(LookAt)
-        REGISTER_PARAM_TYPE(TrackEvent)
-        REGISTER_PARAM_TYPE(ShakeAmplitudeA)
-        REGISTER_PARAM_TYPE(ShakeAmplitudeB)
-        REGISTER_PARAM_TYPE(ShakeFrequencyA)
-        REGISTER_PARAM_TYPE(ShakeFrequencyB)
-        REGISTER_PARAM_TYPE(ShakeMultiplier)
-        REGISTER_PARAM_TYPE(ShakeNoise)
-        REGISTER_PARAM_TYPE(ShakeWorking)
-        REGISTER_PARAM_TYPE(ShakeAmpAMult)
-        REGISTER_PARAM_TYPE(ShakeAmpBMult)
-        REGISTER_PARAM_TYPE(ShakeFreqAMult)
-        REGISTER_PARAM_TYPE(ShakeFreqBMult)
-        REGISTER_PARAM_TYPE(DepthOfField)
-        REGISTER_PARAM_TYPE(FocusDistance)
-        REGISTER_PARAM_TYPE(FocusRange)
-        REGISTER_PARAM_TYPE(BlurAmount)
-        REGISTER_PARAM_TYPE(Capture)
-        REGISTER_PARAM_TYPE(TransformNoise)
-        REGISTER_PARAM_TYPE(TimeWarp)
-        REGISTER_PARAM_TYPE(FixedTimeStep)
-        REGISTER_PARAM_TYPE(NearZ)
-        REGISTER_PARAM_TYPE(Goto)
-        REGISTER_PARAM_TYPE(PositionX)
-        REGISTER_PARAM_TYPE(PositionY)
-        REGISTER_PARAM_TYPE(PositionZ)
-        REGISTER_PARAM_TYPE(RotationX)
-        REGISTER_PARAM_TYPE(RotationY)
-        REGISTER_PARAM_TYPE(RotationZ)
-        REGISTER_PARAM_TYPE(ScaleX)
-        REGISTER_PARAM_TYPE(ScaleY)
-        REGISTER_PARAM_TYPE(ScaleZ)
-        REGISTER_PARAM_TYPE(ColorR)
-        REGISTER_PARAM_TYPE(ColorG)
-        REGISTER_PARAM_TYPE(ColorB)
-        REGISTER_PARAM_TYPE(CommentText)
-        REGISTER_PARAM_TYPE(ScreenFader)
-        REGISTER_PARAM_TYPE(LightDiffuse)
-        REGISTER_PARAM_TYPE(LightRadius)
-        REGISTER_PARAM_TYPE(LightDiffuseMult)
-        REGISTER_PARAM_TYPE(LightHDRDynamic)
-        REGISTER_PARAM_TYPE(LightSpecularMult)
-        REGISTER_PARAM_TYPE(LightSpecPercentage)
-        REGISTER_PARAM_TYPE(MaterialDiffuse)
-        REGISTER_PARAM_TYPE(MaterialSpecular)
-        REGISTER_PARAM_TYPE(MaterialEmissive)
-        REGISTER_PARAM_TYPE(MaterialEmissiveIntensity)
-        REGISTER_PARAM_TYPE(MaterialOpacity)
-        REGISTER_PARAM_TYPE(MaterialSmoothness)
-        REGISTER_PARAM_TYPE(TimeRanges)
-        REGISTER_PARAM_TYPE(Physics)
-        REGISTER_PARAM_TYPE(GSMCache)
-        REGISTER_PARAM_TYPE(ShutterSpeed)
-        REGISTER_PARAM_TYPE(Physicalize)
-        REGISTER_PARAM_TYPE(PhysicsDriven)
-        REGISTER_PARAM_TYPE(SunLongitude)
-        REGISTER_PARAM_TYPE(SunLatitude)
-        REGISTER_PARAM_TYPE(MoonLongitude)
-        REGISTER_PARAM_TYPE(MoonLatitude)
-        REGISTER_PARAM_TYPE(ProceduralEyes)
-    }
+    REGISTER_PARAM_TYPE(FOV)
+    REGISTER_PARAM_TYPE(Position)
+    REGISTER_PARAM_TYPE(Rotation)
+    REGISTER_PARAM_TYPE(Scale)
+    REGISTER_PARAM_TYPE(Event)
+    REGISTER_PARAM_TYPE(Visibility)
+    REGISTER_PARAM_TYPE(Camera)
+    REGISTER_PARAM_TYPE(Animation)
+    REGISTER_PARAM_TYPE(Sound)
+    REGISTER_PARAM_TYPE(Sequence)
+    REGISTER_PARAM_TYPE(Console)
+    REGISTER_PARAM_TYPE(Music)                      ///@deprecated in 1.11, left in for legacy serialization
+    REGISTER_PARAM_TYPE(Float)
+    REGISTER_PARAM_TYPE(LookAt)
+    REGISTER_PARAM_TYPE(TrackEvent)
+    REGISTER_PARAM_TYPE(ShakeAmplitudeA)
+    REGISTER_PARAM_TYPE(ShakeAmplitudeB)
+    REGISTER_PARAM_TYPE(ShakeFrequencyA)
+    REGISTER_PARAM_TYPE(ShakeFrequencyB)
+    REGISTER_PARAM_TYPE(ShakeMultiplier)
+    REGISTER_PARAM_TYPE(ShakeNoise)
+    REGISTER_PARAM_TYPE(ShakeWorking)
+    REGISTER_PARAM_TYPE(ShakeAmpAMult)
+    REGISTER_PARAM_TYPE(ShakeAmpBMult)
+    REGISTER_PARAM_TYPE(ShakeFreqAMult)
+    REGISTER_PARAM_TYPE(ShakeFreqBMult)
+    REGISTER_PARAM_TYPE(DepthOfField)
+    REGISTER_PARAM_TYPE(FocusDistance)
+    REGISTER_PARAM_TYPE(FocusRange)
+    REGISTER_PARAM_TYPE(BlurAmount)
+    REGISTER_PARAM_TYPE(Capture)
+    REGISTER_PARAM_TYPE(TransformNoise)
+    REGISTER_PARAM_TYPE(TimeWarp)
+    REGISTER_PARAM_TYPE(FixedTimeStep)
+    REGISTER_PARAM_TYPE(NearZ)
+    REGISTER_PARAM_TYPE(Goto)
+    REGISTER_PARAM_TYPE(PositionX)
+    REGISTER_PARAM_TYPE(PositionY)
+    REGISTER_PARAM_TYPE(PositionZ)
+    REGISTER_PARAM_TYPE(RotationX)
+    REGISTER_PARAM_TYPE(RotationY)
+    REGISTER_PARAM_TYPE(RotationZ)
+    REGISTER_PARAM_TYPE(ScaleX)
+    REGISTER_PARAM_TYPE(ScaleY)
+    REGISTER_PARAM_TYPE(ScaleZ)
+    REGISTER_PARAM_TYPE(ColorR)
+    REGISTER_PARAM_TYPE(ColorG)
+    REGISTER_PARAM_TYPE(ColorB)
+    REGISTER_PARAM_TYPE(CommentText)
+    REGISTER_PARAM_TYPE(ScreenFader)
+    REGISTER_PARAM_TYPE(LightDiffuse)
+    REGISTER_PARAM_TYPE(LightRadius)
+    REGISTER_PARAM_TYPE(LightDiffuseMult)
+    REGISTER_PARAM_TYPE(LightHDRDynamic)
+    REGISTER_PARAM_TYPE(LightSpecularMult)
+    REGISTER_PARAM_TYPE(LightSpecPercentage)
+    REGISTER_PARAM_TYPE(MaterialDiffuse)
+    REGISTER_PARAM_TYPE(MaterialSpecular)
+    REGISTER_PARAM_TYPE(MaterialEmissive)
+    REGISTER_PARAM_TYPE(MaterialEmissiveIntensity)
+    REGISTER_PARAM_TYPE(MaterialOpacity)
+    REGISTER_PARAM_TYPE(MaterialSmoothness)
+    REGISTER_PARAM_TYPE(TimeRanges)
+    REGISTER_PARAM_TYPE(Physics)
+    REGISTER_PARAM_TYPE(GSMCache)
+    REGISTER_PARAM_TYPE(ShutterSpeed)
+    REGISTER_PARAM_TYPE(Physicalize)
+    REGISTER_PARAM_TYPE(PhysicsDriven)
+    REGISTER_PARAM_TYPE(SunLongitude)
+    REGISTER_PARAM_TYPE(SunLatitude)
+    REGISTER_PARAM_TYPE(MoonLongitude)
+    REGISTER_PARAM_TYPE(MoonLatitude)
+    REGISTER_PARAM_TYPE(ProceduralEyes)
 }
 
 namespace Internal
@@ -1666,16 +1645,16 @@ void CMovieSystem::SerializeNodeType(AnimNodeType& animNodeType, XmlNodeRef& xml
             XmlString nodeTypeString;
             if (xmlNode->getAttr(kType, nodeTypeString))
             {
-                assert(g_animNodeStringToEnumMap.find(nodeTypeString.c_str()) != g_animNodeStringToEnumMap.end());
-                animNodeType = stl::find_in_map(g_animNodeStringToEnumMap, nodeTypeString.c_str(), AnimNodeType::Invalid);
+                assert(m_animNodeStringToEnumMap.find(nodeTypeString.c_str()) != m_animNodeStringToEnumMap.end());
+                animNodeType = stl::find_in_map(m_animNodeStringToEnumMap, nodeTypeString.c_str(), AnimNodeType::Invalid);
             }
         }
     }
     else
     {
         const char* pTypeString = "Invalid";
-        assert(g_animNodeEnumToStringMap.find(animNodeType) != g_animNodeEnumToStringMap.end());
-        pTypeString = g_animNodeEnumToStringMap[animNodeType].c_str();
+        assert(m_animNodeEnumToStringMap.find(animNodeType) != m_animNodeEnumToStringMap.end());
+        pTypeString = m_animNodeEnumToStringMap[animNodeType].c_str();
         xmlNode->setAttr(kType, pTypeString);
     }
 }
@@ -1744,8 +1723,8 @@ void CMovieSystem::LoadParamTypeFromXml(CAnimParamType& animParamType, const Xml
                     animParamType.m_name = virtualPropertyValue;
                 }
 
-                assert(g_animParamStringToEnumMap.find(paramTypeString.c_str()) != g_animParamStringToEnumMap.end());
-                animParamType.m_type = stl::find_in_map(g_animParamStringToEnumMap, paramTypeString.c_str(), AnimParamType::Invalid);
+                assert(m_animParamStringToEnumMap.find(paramTypeString.c_str()) != m_animParamStringToEnumMap.end());
+                animParamType.m_type = stl::find_in_map(m_animParamStringToEnumMap, paramTypeString.c_str(), AnimParamType::Invalid);
             }
         }
     }
@@ -1775,8 +1754,8 @@ void CMovieSystem::SaveParamTypeToXml(const CAnimParamType& animParamType, XmlNo
             xmlNode->setAttr(CAnimParamTypeXmlNames::kVirtualPropertyName, animParamType.m_name.c_str());
         }
 
-        assert(g_animParamEnumToStringMap.find(animParamType.m_type) != g_animParamEnumToStringMap.end());
-        pTypeString = g_animParamEnumToStringMap[animParamType.m_type].c_str();
+        assert(m_animParamEnumToStringMap.find(animParamType.m_type) != m_animParamEnumToStringMap.end());
+        pTypeString = m_animParamEnumToStringMap[animParamType.m_type].c_str();
     }
 
     xmlNode->setAttr(kParamType, pTypeString);
@@ -1809,9 +1788,9 @@ const char* CMovieSystem::GetParamTypeName(const CAnimParamType& animParamType)
     }
     else
     {
-        if (g_animParamEnumToStringMap.find(animParamType.m_type) != g_animParamEnumToStringMap.end())
+        if (m_animParamEnumToStringMap.contains(animParamType.m_type))
         {
-            return g_animParamEnumToStringMap[animParamType.m_type].c_str();
+            return m_animParamEnumToStringMap[animParamType.m_type].c_str();
         }
     }
 
@@ -1973,13 +1952,13 @@ void CLightAnimWrapper::RemoveCachedLightAnim(const char* name)
 //////////////////////////////////////////////////////////////////////////
 AnimNodeType CMovieSystem::GetNodeTypeFromString(const char* pString) const
 {
-    return stl::find_in_map(g_animNodeStringToEnumMap, pString, AnimNodeType::Invalid);
+    return stl::find_in_map(m_animNodeStringToEnumMap, pString, AnimNodeType::Invalid);
 }
 
 //////////////////////////////////////////////////////////////////////////
 CAnimParamType CMovieSystem::GetParamTypeFromString(const char* pString) const
 {
-    const AnimParamType paramType = stl::find_in_map(g_animParamStringToEnumMap, pString, AnimParamType::Invalid);
+    const AnimParamType paramType = stl::find_in_map(m_animParamStringToEnumMap, pString, AnimParamType::Invalid);
 
     if (paramType != AnimParamType::Invalid)
     {
diff --git a/Gems/Maestro/Code/Source/Cinematics/Movie.h b/Gems/Maestro/Code/Source/Cinematics/Movie.h
index ab2c2e649b..4af2b55ced 100644
--- a/Gems/Maestro/Code/Source/Cinematics/Movie.h
+++ b/Gems/Maestro/Code/Source/Cinematics/Movie.h
@@ -18,6 +18,7 @@
 
 #include <CryCommon/TimeValue.h>
 #include <CryCommon/StaticInstance.h>
+#include <CryCommon/StlUtils.h>
 
 #include "IMovieSystem.h"
 #include "IShader.h"
@@ -192,7 +193,7 @@ public:
     void SaveParamTypeToXml(const CAnimParamType& animParamType, XmlNodeRef& xmlNode) override;
     void SerializeParamType(CAnimParamType& animParamType, XmlNodeRef& xmlNode, bool bLoading, const uint version) override;
 
-    static const char* GetParamTypeName(const CAnimParamType& animParamType);
+    const char* GetParamTypeName(const CAnimParamType& animParamType);
 
     void OnCameraCut();
 
@@ -290,6 +291,23 @@ private:
 
     void ShowPlayedSequencesDebug();
 
+
+    using AnimParamSystemString = AZStd::string;
+
+    template <typename KeyType, typename MappedType, typename Compare = stl::less_stricmp<KeyType>>
+    using AnimSystemOrderedMap = AZStd::map<KeyType, MappedType, Compare>;
+    template <typename KeyType, typename MappedType, typename Hasher = AZStd::hash<KeyType>, typename EqualKey = AZStd::equal_to<>>
+    using AnimSystemUnorderedMap = AZStd::unordered_map<KeyType, MappedType, Hasher, EqualKey>;
+
+    AnimSystemUnorderedMap<AnimNodeType, AnimParamSystemString> m_animNodeEnumToStringMap;
+    AnimSystemOrderedMap<AnimParamSystemString, AnimNodeType> m_animNodeStringToEnumMap;
+
+    AnimSystemUnorderedMap<AnimParamType, AnimParamSystemString> m_animParamEnumToStringMap;
+    AnimSystemOrderedMap<AnimParamSystemString, AnimParamType> m_animParamStringToEnumMap;
+
+    void RegisterNodeTypes();
+    void RegisterParamTypes();
+
 public:
     static float m_mov_cameraPrecacheTime;
 #if !defined(_RELEASE)
diff --git a/Gems/TextureAtlas/Code/Source/TextureAtlasImpl.h b/Gems/TextureAtlas/Code/Source/TextureAtlasImpl.h
index ce2f4826da..bb0ed650e5 100644
--- a/Gems/TextureAtlas/Code/Source/TextureAtlasImpl.h
+++ b/Gems/TextureAtlas/Code/Source/TextureAtlasImpl.h
@@ -33,7 +33,7 @@ namespace TextureAtlasNamespace
     struct hash_case_insensitive : public AZStd::hash<AZStd::string>
     {
         AZ_TYPE_INFO(hash_case_insensitive, "{FE0F4349-D80D-4286-8874-733966A32B29}");
-        inline result_type operator()(const AZStd::string& value) const
+        inline size_t operator()(const AZStd::string& value) const
         {
             AZStd::string lowerStr = value;
             AZStd::to_lower(lowerStr.begin(), lowerStr.end());