From 3fe5901a77519ceb135243f58d70144096ba0848 Mon Sep 17 00:00:00 2001
From: mnaumov <mnaumov@amazon.com>
Date: Wed, 11 Aug 2021 23:25:41 -0700
Subject: [PATCH 01/37] Fixing a crash when unparenting prefab instance in a
 new level

Signed-off-by: mnaumov <mnaumov@amazon.com>
---
 .../PrefabEditorEntityOwnershipService.cpp    |  2 +-
 .../Prefab/PrefabPublicHandler.cpp            | 36 +++++++++++++------
 .../Prefab/PrefabSystemComponent.cpp          | 18 ++++++++++
 .../Prefab/PrefabSystemComponent.h            |  2 ++
 .../Prefab/PrefabSystemComponentInterface.h   |  2 ++
 5 files changed, 48 insertions(+), 12 deletions(-)

diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipService.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipService.cpp
index b5cf5fb878..127f04424b 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipService.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipService.cpp
@@ -202,7 +202,7 @@ namespace AzToolsFramework
         m_rootInstance->SetTemplateId(templateId);
         m_rootInstance->SetTemplateSourcePath(m_loaderInterface->GenerateRelativePath(filename));
         m_rootInstance->SetContainerEntityName("Level");
-        m_prefabSystemComponent->PropagateTemplateChanges(templateId);
+        m_prefabSystemComponent->PropagateTemplateChangesDown(templateId);
 
         return true;
     }
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp
index 69efe33d72..85fe30c252 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp
@@ -482,22 +482,36 @@ namespace AzToolsFramework
             AZStd::unique_ptr<Instance>& sourceInstance, TemplateId targetTemplateId, UndoSystem::URSequencePoint* undoBatch)
         {
             LinkReference nestedInstanceLink = m_prefabSystemComponentInterface->FindLink(sourceInstance->GetLinkId());
-            AZ_Assert(
-                nestedInstanceLink.has_value(),
-                "A valid link was not found for one of the instances provided as input for the CreatePrefab operation.");    
+            if (!nestedInstanceLink)
+            {
+                AZ_Assert(
+                    false,
+                    "A valid link was not found for one of the instances provided as input for the CreatePrefab operation.");
+                return;
+            }
 
             PrefabDomReference nestedInstanceLinkDom = nestedInstanceLink->get().GetLinkDom();
-            AZ_Assert(
-                nestedInstanceLinkDom.has_value(),
-                "A valid DOM was not found for the link corresponding to one of the instances provided as input for the "
-                "CreatePrefab operation.");
+
+            if (!nestedInstanceLinkDom)
+            {
+                AZ_Assert(
+                    false,
+                    "A valid DOM was not found for the link corresponding to one of the instances provided as input for the "
+                    "CreatePrefab operation.");
+                return;
+            }
 
             PrefabDomValueReference nestedInstanceLinkPatches =
                 PrefabDomUtils::FindPrefabDomValue(nestedInstanceLinkDom->get(), PrefabDomUtils::PatchesName);
-            AZ_Assert(
-                nestedInstanceLinkPatches.has_value(),
-                "A valid DOM for patches was not found for the link corresponding to one of the instances provided as input for the "
-                "CreatePrefab operation.");
+
+            if (!nestedInstanceLinkPatches)
+            {
+                AZ_Assert(
+                    false,
+                    "A valid DOM for patches was not found for the link corresponding to one of the instances provided as input for the "
+                    "CreatePrefab operation.");
+                return;
+            }
 
             PrefabDom patchesCopyForUndoSupport;
             patchesCopyForUndoSupport.CopyFrom(nestedInstanceLinkPatches->get(), patchesCopyForUndoSupport.GetAllocator());
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponent.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponent.cpp
index bfdb6b79f2..b75f50198c 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponent.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponent.cpp
@@ -153,6 +153,24 @@ namespace AzToolsFramework
             }
         }
 
+        void PrefabSystemComponent::PropagateTemplateChangesDown(TemplateId templateId, InstanceOptionalReference instanceToExclude)
+        {
+            PropagateTemplateChanges(templateId, instanceToExclude);
+
+            auto templateIterator = m_templateIdMap.find(templateId);
+            if (templateIterator != m_templateIdMap.end())
+            {
+                for (LinkId linkId : templateIterator->second.GetLinks())
+                {
+                    auto linkIterator = m_linkIdMap.find(linkId);
+                    if (linkIterator != m_linkIdMap.end())
+                    {
+                        PropagateTemplateChangesDown(linkIterator->second.GetSourceTemplateId(), instanceToExclude);
+                    }
+                }
+            }
+        }
+
         void PrefabSystemComponent::UpdatePrefabTemplate(TemplateId templateId, const PrefabDom& updatedDom)
         {
             auto templateToUpdate = FindTemplate(templateId);
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponent.h b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponent.h
index 04457b5a97..ccc17af133 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponent.h
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponent.h
@@ -213,6 +213,8 @@ namespace AzToolsFramework
 
             void PropagateTemplateChanges(TemplateId templateId, InstanceOptionalReference instanceToExclude = AZStd::nullopt) override;
 
+            void PropagateTemplateChangesDown(TemplateId templateIdd, InstanceOptionalReference instanceToExclude = AZStd::nullopt) override;
+
             /**
              * Updates all Instances owned by a Template.
              *
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponentInterface.h b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponentInterface.h
index 0c758a21af..9792ec0fab 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponentInterface.h
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponentInterface.h
@@ -53,6 +53,8 @@ namespace AzToolsFramework
             virtual PrefabDom& FindTemplateDom(TemplateId templateId) = 0;
             virtual void UpdatePrefabTemplate(TemplateId templateId, const PrefabDom& updatedDom) = 0;
             virtual void PropagateTemplateChanges(TemplateId templateId, InstanceOptionalReference instanceToExclude = AZStd::nullopt) = 0;
+            //! Propagates template changes recursively down to its dependents
+            virtual void PropagateTemplateChangesDown(TemplateId templateIdd, InstanceOptionalReference instanceToExclude = AZStd::nullopt) = 0;
 
             virtual AZStd::unique_ptr<Instance> InstantiatePrefab(AZ::IO::PathView filePath) = 0;
             virtual AZStd::unique_ptr<Instance> InstantiatePrefab(const TemplateId& templateId) = 0;

From 8f21563ba95d042fc8263eacdd9821c4a93ab4f9 Mon Sep 17 00:00:00 2001
From: mnaumov <mnaumov@amazon.com>
Date: Thu, 12 Aug 2021 14:37:01 -0700
Subject: [PATCH 02/37] Undoing old changes and storing linkId to prefabDom

Signed-off-by: mnaumov <mnaumov@amazon.com>
---
 .../PrefabEditorEntityOwnershipService.cpp     |  2 +-
 .../Prefab/Instance/InstanceSerializer.cpp     |  7 +++++++
 .../Prefab/PrefabSystemComponent.cpp           | 18 ------------------
 .../Prefab/PrefabSystemComponent.h             |  2 --
 .../Prefab/PrefabSystemComponentInterface.h    |  2 --
 5 files changed, 8 insertions(+), 23 deletions(-)

diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipService.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipService.cpp
index 127f04424b..b5cf5fb878 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipService.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipService.cpp
@@ -202,7 +202,7 @@ namespace AzToolsFramework
         m_rootInstance->SetTemplateId(templateId);
         m_rootInstance->SetTemplateSourcePath(m_loaderInterface->GenerateRelativePath(filename));
         m_rootInstance->SetContainerEntityName("Level");
-        m_prefabSystemComponent->PropagateTemplateChangesDown(templateId);
+        m_prefabSystemComponent->PropagateTemplateChanges(templateId);
 
         return true;
     }
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Instance/InstanceSerializer.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Instance/InstanceSerializer.cpp
index b5a354ee74..89e0136b12 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Instance/InstanceSerializer.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Instance/InstanceSerializer.cpp
@@ -81,6 +81,13 @@ namespace AzToolsFramework
                 result.Combine(resultInstances);
             }
 
+            {
+                AZ::ScopedContextPath subPathSource(context, "m_linkId");
+
+                result = ContinueStoringToJsonObjectField(
+                    outputValue, "LinkId", &(instance->m_linkId), &InvalidLinkId, azrtti_typeid<AZ::u64>(), context);
+            }
+
             return context.Report(result,
                 result.GetProcessing() == JSR::Processing::Completed ? "Successfully stored Instance information for Prefab." :
                 "Failed to store Instance information for Prefab.");
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponent.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponent.cpp
index b75f50198c..bfdb6b79f2 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponent.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponent.cpp
@@ -153,24 +153,6 @@ namespace AzToolsFramework
             }
         }
 
-        void PrefabSystemComponent::PropagateTemplateChangesDown(TemplateId templateId, InstanceOptionalReference instanceToExclude)
-        {
-            PropagateTemplateChanges(templateId, instanceToExclude);
-
-            auto templateIterator = m_templateIdMap.find(templateId);
-            if (templateIterator != m_templateIdMap.end())
-            {
-                for (LinkId linkId : templateIterator->second.GetLinks())
-                {
-                    auto linkIterator = m_linkIdMap.find(linkId);
-                    if (linkIterator != m_linkIdMap.end())
-                    {
-                        PropagateTemplateChangesDown(linkIterator->second.GetSourceTemplateId(), instanceToExclude);
-                    }
-                }
-            }
-        }
-
         void PrefabSystemComponent::UpdatePrefabTemplate(TemplateId templateId, const PrefabDom& updatedDom)
         {
             auto templateToUpdate = FindTemplate(templateId);
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponent.h b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponent.h
index ccc17af133..04457b5a97 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponent.h
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponent.h
@@ -213,8 +213,6 @@ namespace AzToolsFramework
 
             void PropagateTemplateChanges(TemplateId templateId, InstanceOptionalReference instanceToExclude = AZStd::nullopt) override;
 
-            void PropagateTemplateChangesDown(TemplateId templateIdd, InstanceOptionalReference instanceToExclude = AZStd::nullopt) override;
-
             /**
              * Updates all Instances owned by a Template.
              *
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponentInterface.h b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponentInterface.h
index 9792ec0fab..0c758a21af 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponentInterface.h
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponentInterface.h
@@ -53,8 +53,6 @@ namespace AzToolsFramework
             virtual PrefabDom& FindTemplateDom(TemplateId templateId) = 0;
             virtual void UpdatePrefabTemplate(TemplateId templateId, const PrefabDom& updatedDom) = 0;
             virtual void PropagateTemplateChanges(TemplateId templateId, InstanceOptionalReference instanceToExclude = AZStd::nullopt) = 0;
-            //! Propagates template changes recursively down to its dependents
-            virtual void PropagateTemplateChangesDown(TemplateId templateIdd, InstanceOptionalReference instanceToExclude = AZStd::nullopt) = 0;
 
             virtual AZStd::unique_ptr<Instance> InstantiatePrefab(AZ::IO::PathView filePath) = 0;
             virtual AZStd::unique_ptr<Instance> InstantiatePrefab(const TemplateId& templateId) = 0;

From c8cd3b1923971bf0b17b0b0fbcb7ad8d44c699ea Mon Sep 17 00:00:00 2001
From: mnaumov <mnaumov@amazon.com>
Date: Thu, 12 Aug 2021 14:39:15 -0700
Subject: [PATCH 03/37] reverting another file

Signed-off-by: mnaumov <mnaumov@amazon.com>
---
 .../Prefab/PrefabPublicHandler.cpp            | 36 ++++++-------------
 1 file changed, 11 insertions(+), 25 deletions(-)

diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp
index 85fe30c252..69efe33d72 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp
@@ -482,36 +482,22 @@ namespace AzToolsFramework
             AZStd::unique_ptr<Instance>& sourceInstance, TemplateId targetTemplateId, UndoSystem::URSequencePoint* undoBatch)
         {
             LinkReference nestedInstanceLink = m_prefabSystemComponentInterface->FindLink(sourceInstance->GetLinkId());
-            if (!nestedInstanceLink)
-            {
-                AZ_Assert(
-                    false,
-                    "A valid link was not found for one of the instances provided as input for the CreatePrefab operation.");
-                return;
-            }
+            AZ_Assert(
+                nestedInstanceLink.has_value(),
+                "A valid link was not found for one of the instances provided as input for the CreatePrefab operation.");    
 
             PrefabDomReference nestedInstanceLinkDom = nestedInstanceLink->get().GetLinkDom();
-
-            if (!nestedInstanceLinkDom)
-            {
-                AZ_Assert(
-                    false,
-                    "A valid DOM was not found for the link corresponding to one of the instances provided as input for the "
-                    "CreatePrefab operation.");
-                return;
-            }
+            AZ_Assert(
+                nestedInstanceLinkDom.has_value(),
+                "A valid DOM was not found for the link corresponding to one of the instances provided as input for the "
+                "CreatePrefab operation.");
 
             PrefabDomValueReference nestedInstanceLinkPatches =
                 PrefabDomUtils::FindPrefabDomValue(nestedInstanceLinkDom->get(), PrefabDomUtils::PatchesName);
-
-            if (!nestedInstanceLinkPatches)
-            {
-                AZ_Assert(
-                    false,
-                    "A valid DOM for patches was not found for the link corresponding to one of the instances provided as input for the "
-                    "CreatePrefab operation.");
-                return;
-            }
+            AZ_Assert(
+                nestedInstanceLinkPatches.has_value(),
+                "A valid DOM for patches was not found for the link corresponding to one of the instances provided as input for the "
+                "CreatePrefab operation.");
 
             PrefabDom patchesCopyForUndoSupport;
             patchesCopyForUndoSupport.CopyFrom(nestedInstanceLinkPatches->get(), patchesCopyForUndoSupport.GetAllocator());

From e633b5bdc70ca5b4ea3bb8cc7cd55e7e0acd3e8d Mon Sep 17 00:00:00 2001
From: mnaumov <mnaumov@amazon.com>
Date: Fri, 13 Aug 2021 19:43:38 -0700
Subject: [PATCH 04/37] Addressing Ronald's feedback

Signed-off-by: mnaumov <mnaumov@amazon.com>
---
 .../Prefab/Instance/InstanceSerializer.cpp           |  3 +++
 .../AzToolsFramework/Prefab/PrefabDomUtils.cpp       |  6 ++++++
 .../AzToolsFramework/Prefab/PrefabDomUtils.h         | 12 +++++++++++-
 .../AzToolsFramework/Prefab/PrefabLoader.cpp         |  2 +-
 4 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Instance/InstanceSerializer.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Instance/InstanceSerializer.cpp
index 89e0136b12..af42919637 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Instance/InstanceSerializer.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Instance/InstanceSerializer.cpp
@@ -15,6 +15,7 @@
 #include <AzToolsFramework/Prefab/Instance/InstanceEntityMapperInterface.h>
 #include <AzToolsFramework/Prefab/PrefabLoaderInterface.h>
 #include <AzToolsFramework/Prefab/PrefabSystemComponentInterface.h>
+#include <Prefab/PrefabDomUtils.h>
 
 namespace AzToolsFramework
 {
@@ -81,6 +82,8 @@ namespace AzToolsFramework
                 result.Combine(resultInstances);
             }
 
+            PrefabDomUtils::LinkIdMetadata** linkIdMetadata = context.GetMetadata().Find<PrefabDomUtils::LinkIdMetadata*>();
+            if (linkIdMetadata && *linkIdMetadata)
             {
                 AZ::ScopedContextPath subPathSource(context, "m_linkId");
 
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabDomUtils.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabDomUtils.cpp
index 86983d7912..c58cb21295 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabDomUtils.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabDomUtils.cpp
@@ -64,6 +64,12 @@ namespace AzToolsFramework
                     settings.m_keepDefaults = true;
                 }
 
+                if ((flags & StoreInstanceFlags::StoreLinkIds) != StoreInstanceFlags::None)
+                {
+                    LinkIdMetadata linkIdMetadata;
+                    settings.m_metadata.Add(&linkIdMetadata);
+                }
+
                 AZ::JsonSerializationResult::ResultCode result =
                     AZ::JsonSerialization::Store(prefabDom, prefabDom.GetAllocator(), instance, settings);
 
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabDomUtils.h b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabDomUtils.h
index e773b581dd..fe38eb9e0f 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabDomUtils.h
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabDomUtils.h
@@ -45,7 +45,11 @@ namespace AzToolsFramework
 
                 //! By default an instance will be stored with default values. In cases where we want to store less json without defaults
                 //! such as saving to disk, this flag will control that behavior.
-                StripDefaultValues = 1 << 0
+                StripDefaultValues = 1 << 0,
+
+                //! We do not save linkIds to file. However when loading a level we want to temporarily save
+                //! linkIds to instance dom so any nested prefabs will have linkIds correctly set.
+                StoreLinkIds = 1 << 1
             };
             AZ_DEFINE_ENUM_BITWISE_OPERATORS(StoreInstanceFlags);
 
@@ -138,6 +142,12 @@ namespace AzToolsFramework
                 [[maybe_unused]] const AZStd::string_view printMessage,
                 [[maybe_unused]] const AzToolsFramework::Prefab::PrefabDomValue& prefabDomValue);
 
+            //! An empty struct for passing to JsonSerializerSettings.m_metadata that is consumed by InstanceSerializer::Store.
+            //! If present in metadata, linkIds will be stored to instance dom.
+            struct LinkIdMetadata
+            {
+                AZ_RTTI(LinkIdMetadata, "{8FF7D299-14E3-41D4-90C5-393A240FAE7C}");
+            };
         } // namespace PrefabDomUtils
     } // namespace Prefab
 } // namespace AzToolsFramework
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabLoader.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabLoader.cpp
index ea54c9d10c..2b16134744 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabLoader.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabLoader.cpp
@@ -300,7 +300,7 @@ namespace AzToolsFramework
             }
 
             PrefabDom storedPrefabDom(&loadedTemplateDom->get().GetAllocator());
-            if (!PrefabDomUtils::StoreInstanceInPrefabDom(loadedPrefabInstance, storedPrefabDom))
+            if (!PrefabDomUtils::StoreInstanceInPrefabDom(loadedPrefabInstance, storedPrefabDom, PrefabDomUtils::StoreInstanceFlags::StoreLinkIds))
             {
                 return false;
             }

From 9aa391bf7413d15f3814cb6115eac95163733fa1 Mon Sep 17 00:00:00 2001
From: mnaumov <mnaumov@amazon.com>
Date: Fri, 13 Aug 2021 16:54:57 -0700
Subject: [PATCH 05/37] Fixing Level Save As

Signed-off-by: mnaumov <mnaumov@amazon.com>
---
 .../PrefabEditorEntityOwnershipService.cpp    | 36 ++-----------------
 1 file changed, 2 insertions(+), 34 deletions(-)

diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipService.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipService.cpp
index b5cf5fb878..7df1e1b5c1 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipService.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipService.cpp
@@ -219,42 +219,10 @@ namespace AzToolsFramework
     bool PrefabEditorEntityOwnershipService::SaveToStream(AZ::IO::GenericStream& stream, AZStd::string_view 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)
-        {
-            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 false;
-            }
-            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));
-                return false;
-            }
-        }
-
-        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);
-        }
-
+        
         AZStd::string out;
-
         if (!m_loaderInterface->SaveTemplateToString(m_rootInstance->GetTemplateId(), out))
         {
             return false;
@@ -266,7 +234,7 @@ namespace AzToolsFramework
         {
             return false;
         }
-        m_prefabSystemComponent->SetTemplateDirtyFlag(templateId, false);
+        m_prefabSystemComponent->SetTemplateDirtyFlag(m_rootInstance->GetTemplateId(), false);
         return true;
     }
 

From 9ecb746563909b6092156ffade30d25077508e44 Mon Sep 17 00:00:00 2001
From: lsemp3d <58790905+lsemp3d@users.noreply.github.com>
Date: Sat, 14 Aug 2021 16:50:57 -0700
Subject: [PATCH 06/37] Completed namespace support for the ScriptCanvasGrammar
 template

Signed-off-by: lsemp3d <58790905+lsemp3d@users.noreply.github.com>
---
 .../AutoGen/ScriptCanvasGrammar_Header.jinja  |  2 +-
 .../AutoGen/ScriptCanvasGrammar_Source.jinja  | 21 ++++++++++++++++++-
 2 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/AutoGen/ScriptCanvasGrammar_Header.jinja b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/AutoGen/ScriptCanvasGrammar_Header.jinja
index 00c23b9f35..d743a95ee1 100644
--- a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/AutoGen/ScriptCanvasGrammar_Header.jinja
+++ b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/AutoGen/ScriptCanvasGrammar_Header.jinja
@@ -77,7 +77,7 @@ public: \
 {% if Class.attrib['GraphEntryPoint'] is defined %}    bool IsEntryPoint() const override { return {%if Class.attrib['GraphEntryPoint'] == "True" %}true{%else%}false{%endif%}; } \
 {% endif %}
 public: \
-    friend struct ::{{ className | replace(' ','') }}Property;
+    friend struct {% if attribute_Namespace is not defined %}::{% endif %}{{ className | replace(' ','') }}Property;
 
 // Helpers for easily accessing properties and slots
 struct {{ className | replace(' ','') }}Property
diff --git a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/AutoGen/ScriptCanvasGrammar_Source.jinja b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/AutoGen/ScriptCanvasGrammar_Source.jinja
index 205e6ebd8c..6a381398c1 100644
--- a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/AutoGen/ScriptCanvasGrammar_Source.jinja
+++ b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/AutoGen/ScriptCanvasGrammar_Source.jinja
@@ -26,6 +26,20 @@ SPDX-License-Identifier: Apache-2.0 OR MIT
 #include "{{ xml.attrib['Include'] }}"
 
 {%     for Class in xml.iter('Class') %}
+
+{% set attribute_Namespace = undefined %}
+{%- if Class.attrib['Namespace'] is defined %}
+{%      if Class.attrib['Namespace'] != "None" %}
+{%          set attribute_Namespace = Class.attrib['Namespace'] %}
+{%      endif %}
+{% endif %}
+
+{% if attribute_Namespace is defined %}
+namespace {{attribute_Namespace}} 
+{
+{% endif %}
+
+
 void {{ Class.attrib['QualifiedName'] }}::ConfigureSlots()
 {
 {% if Class.attrib['Base'] is defined %}
@@ -269,7 +283,12 @@ void {{ Class.attrib['QualifiedName'] }}::Reflect(AZ::ReflectContext* context)
     return datumValue ? *datumValue : {{ Property.attrib['Type'] }}();
 }
 
-
 {%         endfor %}
+
+{% if attribute_Namespace is defined %}
+}
+{% endif %}
+
+
 {%     endfor %}
 {% endfor %}

From 0884f96997ab18916b4b83ce01f167eb75d1eea6 Mon Sep 17 00:00:00 2001
From: mnaumov <mnaumov@amazon.com>
Date: Mon, 16 Aug 2021 16:00:18 -0700
Subject: [PATCH 07/37] PR feedback

Signed-off-by: mnaumov <mnaumov@amazon.com>
---
 .../AzToolsFramework/Prefab/Instance/InstanceSerializer.cpp | 6 +++---
 .../AzToolsFramework/Prefab/PrefabDomUtils.cpp              | 3 +--
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Instance/InstanceSerializer.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Instance/InstanceSerializer.cpp
index af42919637..92b37b10db 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Instance/InstanceSerializer.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Instance/InstanceSerializer.cpp
@@ -82,13 +82,13 @@ namespace AzToolsFramework
                 result.Combine(resultInstances);
             }
 
-            PrefabDomUtils::LinkIdMetadata** linkIdMetadata = context.GetMetadata().Find<PrefabDomUtils::LinkIdMetadata*>();
-            if (linkIdMetadata && *linkIdMetadata)
+            PrefabDomUtils::LinkIdMetadata* subPathLinkId = context.GetMetadata().Find<PrefabDomUtils::LinkIdMetadata>();
+            if (subPathLinkId)
             {
                 AZ::ScopedContextPath subPathSource(context, "m_linkId");
 
                 result = ContinueStoringToJsonObjectField(
-                    outputValue, "LinkId", &(instance->m_linkId), &InvalidLinkId, azrtti_typeid<AZ::u64>(), context);
+                    outputValue, "LinkId", &(instance->m_linkId), &InvalidLinkId, azrtti_typeid<decltype(instance->m_linkId)>(), context);
             }
 
             return context.Report(result,
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabDomUtils.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabDomUtils.cpp
index 2462bc0348..dcc14d3b91 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabDomUtils.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabDomUtils.cpp
@@ -90,8 +90,7 @@ namespace AzToolsFramework
 
                 if ((flags & StoreFlags::StoreLinkIds) != StoreFlags::None)
                 {
-                    LinkIdMetadata linkIdMetadata;
-                    settings.m_metadata.Add(&linkIdMetadata);
+                    settings.m_metadata.Create<LinkIdMetadata>();
                 }
 
                 AZStd::string scratchBuffer;

From a20428d3933beb532430e09950ef26b104bc982f Mon Sep 17 00:00:00 2001
From: mnaumov <mnaumov@amazon.com>
Date: Mon, 16 Aug 2021 23:16:04 -0700
Subject: [PATCH 08/37] Fixing non unity build

Signed-off-by: Mikhail Naumov <mnaumov@amazon.com>
---
 .../AzToolsFramework/AzToolsFramework/Prefab/PrefabDomUtils.h   | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabDomUtils.h b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabDomUtils.h
index 77b4b752a6..7cab24ad9f 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabDomUtils.h
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabDomUtils.h
@@ -159,6 +159,8 @@ namespace AzToolsFramework
             struct LinkIdMetadata
             {
                 AZ_RTTI(LinkIdMetadata, "{8FF7D299-14E3-41D4-90C5-393A240FAE7C}");
+
+                virtual ~LinkIdMetadata() {}
             };
         } // namespace PrefabDomUtils
     } // namespace Prefab

From 8f4a35b146af277ad903ab5522c33a2362ce2cb7 Mon Sep 17 00:00:00 2001
From: Guthrie Adams <guthadam@amazon.com>
Date: Tue, 17 Aug 2021 13:21:13 -0500
Subject: [PATCH 09/37] AtomTools: fix unused variable errors

Signed-off-by: Guthrie Adams <guthadam@amazon.com>
---
 .../Code/Source/Document/AtomToolsDocument.cpp            | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Document/AtomToolsDocument.cpp b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Document/AtomToolsDocument.cpp
index 48212fe154..e8eb9401d4 100644
--- a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Document/AtomToolsDocument.cpp
+++ b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Document/AtomToolsDocument.cpp
@@ -40,29 +40,35 @@ namespace AtomToolsFramework
 
     const AZStd::any& AtomToolsDocument::GetPropertyValue(const AZ::Name& propertyFullName) const
     {
+        AZ_UNUSED(propertyFullName);
         AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
         return m_invalidValue;
     }
 
     const AtomToolsFramework::DynamicProperty& AtomToolsDocument::GetProperty(const AZ::Name& propertyFullName) const
     {
+        AZ_UNUSED(propertyFullName);
         AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
         return m_invalidProperty;
     }
     
     bool AtomToolsDocument::IsPropertyGroupVisible(const AZ::Name& propertyGroupFullName) const
     {
+        AZ_UNUSED(propertyGroupFullName);
         AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
         return false;
     }
 
     void AtomToolsDocument::SetPropertyValue(const AZ::Name& propertyFullName, const AZStd::any& value)
     {
+        AZ_UNUSED(propertyFullName);
+        AZ_UNUSED(value);
         AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
     }
 
     bool AtomToolsDocument::Open(AZStd::string_view loadPath)
     {
+        AZ_UNUSED(loadPath);
         AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
         return false;
     }
@@ -81,6 +87,7 @@ namespace AtomToolsFramework
 
     bool AtomToolsDocument::SaveAsCopy(AZStd::string_view savePath)
     {
+        AZ_UNUSED(savePath);
         AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
         return false;
     }
@@ -88,6 +95,7 @@ namespace AtomToolsFramework
 
     bool AtomToolsDocument::SaveAsChild(AZStd::string_view savePath)
     {
+        AZ_UNUSED(savePath);
         AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
         return false;
     }

From e865ad5d2368096caf00896dd0fdb0eee846c139 Mon Sep 17 00:00:00 2001
From: Jacob Hilliard <64656371+jcbhl@users.noreply.github.com>
Date: Tue, 17 Aug 2021 11:33:13 -0700
Subject: [PATCH 10/37] Profiler: implement loading from saved captures (#3026)

* Profiler: implement loading from saved capture
Adds functionality for finding a saved capture on disk and then
deserializing it using rapidjson's built-in buffered stream reader. This
does require use of raw file pointers since saved captures can be
hundreds of megabytes.
Actually showing the data in the visualizer is TODO.
* Profiler: use heap buffer over stack buffer
* Profiler: move deserialization logic to ImGuiCpuProfiler

Signed-off-by: Jacob Hilliard <jhlliar@amazon.com>
---
 .../ProfilingCaptureSystemComponent.cpp       |  98 +-----------
 .../Code/Include/Atom/RHI/CpuProfilerImpl.h   |  31 +++-
 .../RHI/Code/Source/RHI/CpuProfilerImpl.cpp   |  63 +++++++-
 .../Include/Atom/RPI.Edit/Common/JsonUtils.h  |   3 +-
 .../Include/Atom/Utils/ImGuiCpuProfiler.h     |  15 ++
 .../Include/Atom/Utils/ImGuiCpuProfiler.inl   | 151 +++++++++++++++++-
 6 files changed, 260 insertions(+), 101 deletions(-)

diff --git a/Gems/Atom/Feature/Common/Code/Source/ProfilingCaptureSystemComponent.cpp b/Gems/Atom/Feature/Common/Code/Source/ProfilingCaptureSystemComponent.cpp
index add6d0e098..7c6dfcf744 100644
--- a/Gems/Atom/Feature/Common/Code/Source/ProfilingCaptureSystemComponent.cpp
+++ b/Gems/Atom/Feature/Common/Code/Source/ProfilingCaptureSystemComponent.cpp
@@ -9,6 +9,7 @@
 #include "ProfilingCaptureSystemComponent.h"
 
 #include <Atom/RHI/CpuProfiler.h>
+#include <Atom/RHI/CpuProfilerImpl.h>
 #include <Atom/RHI/RHIUtils.h>
 #include <Atom/RHI/RHISystemInterface.h>
 #include <Atom/RHI.Reflect/CpuTimingStatistics.h>
@@ -141,36 +142,6 @@ namespace AZ
             AZStd::vector<PipelineStatisticsSerializerEntry> m_pipelineStatisticsEntries;
         };
 
-        // Intermediate class to serialize Cpu TimedRegion data.
-        class CpuProfilingStatisticsSerializer
-        {
-        public:
-            class CpuProfilingStatisticsSerializerEntry
-            {
-            public:
-                AZ_TYPE_INFO(CpuProfilingStatisticsSerializer::CpuProfilingStatisticsSerializerEntry, "{26B78F65-EB96-46E2-BE7E-A1233880B225}");
-                static void Reflect(AZ::ReflectContext* context);
-
-                CpuProfilingStatisticsSerializerEntry() = default;
-                CpuProfilingStatisticsSerializerEntry(const RHI::CachedTimeRegion& cachedTimeRegion);
-
-            private:
-                Name m_groupName;
-                Name m_regionName;
-                uint16_t m_stackDepth;
-                AZStd::sys_time_t m_startTick;
-                AZStd::sys_time_t m_endTick;
-            };
-
-            AZ_TYPE_INFO(CpuProfilingStatisticsSerializer, "{D5B02946-0D27-474F-9A44-364C2706DD41}");
-            static void Reflect(AZ::ReflectContext* context);
-
-            CpuProfilingStatisticsSerializer() = default;
-            CpuProfilingStatisticsSerializer(const AZStd::ring_buffer<RHI::CpuProfiler::TimeRegionMap>& continuousData);
-
-            AZStd::vector<CpuProfilingStatisticsSerializerEntry> m_cpuProfilingStatisticsSerializerEntries;
-        };
-
         // Intermediate class to serialize benchmark metadata.
         class BenchmarkMetadataSerializer
         {
@@ -327,65 +298,6 @@ namespace AZ
             }
         }
 
-        // --- CpuProfilingStatisticsSerializer ---
-
-        CpuProfilingStatisticsSerializer::CpuProfilingStatisticsSerializer(const AZStd::ring_buffer<RHI::CpuProfiler::TimeRegionMap>& continuousData)
-        {
-            // Create serializable entries
-            for (const auto& timeRegionMap : continuousData)
-            {
-                for (const auto& threadEntry : timeRegionMap)
-                {
-                    for (const auto& cachedRegionEntry : threadEntry.second)
-                    {
-                        m_cpuProfilingStatisticsSerializerEntries.insert(
-                            m_cpuProfilingStatisticsSerializerEntries.end(),
-                            cachedRegionEntry.second.begin(),
-                            cachedRegionEntry.second.end());
-                    }
-                }
-            }
-        }
-
-        void CpuProfilingStatisticsSerializer::Reflect(AZ::ReflectContext* context)
-        {
-            if (auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
-            {
-                serializeContext->Class<CpuProfilingStatisticsSerializer>()
-                    ->Version(1)
-                    ->Field("cpuProfilingStatisticsSerializerEntry", &CpuProfilingStatisticsSerializer::m_cpuProfilingStatisticsSerializerEntries)
-                    ;
-            }
-
-            CpuProfilingStatisticsSerializerEntry::Reflect(context);
-        }
-
-        // --- CpuProfilingStatisticsSerializerEntry ---
-
-        CpuProfilingStatisticsSerializer::CpuProfilingStatisticsSerializerEntry::CpuProfilingStatisticsSerializerEntry(const RHI::CachedTimeRegion& cachedTimeRegion)
-        {
-            m_groupName = cachedTimeRegion.m_groupRegionName->m_groupName;
-            m_regionName = cachedTimeRegion.m_groupRegionName->m_regionName;
-            m_stackDepth = cachedTimeRegion.m_stackDepth;
-            m_startTick = cachedTimeRegion.m_startTick;
-            m_endTick = cachedTimeRegion.m_endTick;
-        }
-
-        void CpuProfilingStatisticsSerializer::CpuProfilingStatisticsSerializerEntry::Reflect(AZ::ReflectContext* context)
-        {
-            if (auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
-            {
-                serializeContext->Class<CpuProfilingStatisticsSerializerEntry>()
-                    ->Version(1)
-                    ->Field("groupName", &CpuProfilingStatisticsSerializerEntry::m_groupName)
-                    ->Field("regionName", &CpuProfilingStatisticsSerializerEntry::m_regionName)
-                    ->Field("stackDepth", &CpuProfilingStatisticsSerializerEntry::m_stackDepth)
-                    ->Field("startTick", &CpuProfilingStatisticsSerializerEntry::m_startTick)
-                    ->Field("endTick", &CpuProfilingStatisticsSerializerEntry::m_endTick)
-                    ;
-            }
-        }
-
         // --- BenchmarkMetadataSerializer ---
 
         BenchmarkMetadataSerializer::BenchmarkMetadataSerializer(const AZStd::string& benchmarkName, const RHI::PhysicalDeviceDescriptor& gpuDescriptor)
@@ -458,7 +370,7 @@ namespace AZ
             TimestampSerializer::Reflect(context);
             CpuFrameTimeSerializer::Reflect(context);
             PipelineStatisticsSerializer::Reflect(context);
-            CpuProfilingStatisticsSerializer::Reflect(context);
+            RHI::CpuProfilingStatisticsSerializer::Reflect(context);
             BenchmarkMetadataSerializer::Reflect(context);
         }
 
@@ -651,10 +563,10 @@ namespace AZ
             JsonSerializerSettings serializationSettings;
             serializationSettings.m_keepDefaults = true;
 
-            CpuProfilingStatisticsSerializer serializer(data);
+            RHI::CpuProfilingStatisticsSerializer serializer(data);
 
             const auto saveResult = JsonSerializationUtils::SaveObjectToFile(&serializer,
-                outputFilePath, (CpuProfilingStatisticsSerializer*)nullptr, &serializationSettings);
+                outputFilePath, (RHI::CpuProfilingStatisticsSerializer*)nullptr, &serializationSettings);
 
             AZStd::string captureInfo = outputFilePath;
             if (!saveResult.IsSuccess())
@@ -694,7 +606,7 @@ namespace AZ
             const bool captureStarted = m_cpuProfilingStatisticsCapture.StartCapture([this, outputFilePath, wasEnabled]()
             {
                 // Blocking call for a single frame of data, avoid thread overhead
-                AZStd::ring_buffer<RHI::CpuProfiler::TimeRegionMap> singleFrameData;
+                AZStd::ring_buffer<RHI::CpuProfiler::TimeRegionMap> singleFrameData(1);
                 singleFrameData.push_back(RHI::CpuProfiler::Get()->GetTimeRegionMap());
                 SerializeCpuProfilingData(singleFrameData, outputFilePath, wasEnabled);
             });
diff --git a/Gems/Atom/RHI/Code/Include/Atom/RHI/CpuProfilerImpl.h b/Gems/Atom/RHI/Code/Include/Atom/RHI/CpuProfilerImpl.h
index 2e4ca67db8..9372977d8e 100644
--- a/Gems/Atom/RHI/Code/Include/Atom/RHI/CpuProfilerImpl.h
+++ b/Gems/Atom/RHI/Code/Include/Atom/RHI/CpuProfilerImpl.h
@@ -12,6 +12,7 @@
 
 #include <AzCore/Component/TickBus.h>
 #include <AzCore/Memory/OSAllocator.h>
+#include <AzCore/Name/Name.h>
 #include <AzCore/std/containers/map.h>
 #include <AzCore/std/containers/unordered_set.h>
 #include <AzCore/std/parallel/mutex.h>
@@ -161,5 +162,33 @@ namespace AZ
             AZStd::ring_buffer<TimeRegionMap> m_continuousCaptureData;
         };
 
-    }; // namespace RPI
+        // Intermediate class to serialize Cpu TimedRegion data.
+        class CpuProfilingStatisticsSerializer
+        {
+        public:
+            class CpuProfilingStatisticsSerializerEntry
+            {
+            public:
+                AZ_TYPE_INFO(CpuProfilingStatisticsSerializer::CpuProfilingStatisticsSerializerEntry, "{26B78F65-EB96-46E2-BE7E-A1233880B225}");
+                static void Reflect(AZ::ReflectContext* context);
+
+                CpuProfilingStatisticsSerializerEntry() = default;
+                CpuProfilingStatisticsSerializerEntry(const RHI::CachedTimeRegion& cachedTimeRegion);
+
+                Name m_groupName;
+                Name m_regionName;
+                uint16_t m_stackDepth;
+                AZStd::sys_time_t m_startTick;
+                AZStd::sys_time_t m_endTick;
+            };
+
+            AZ_TYPE_INFO(CpuProfilingStatisticsSerializer, "{D5B02946-0D27-474F-9A44-364C2706DD41}");
+            static void Reflect(AZ::ReflectContext* context);
+
+            CpuProfilingStatisticsSerializer() = default;
+            CpuProfilingStatisticsSerializer(const AZStd::ring_buffer<RHI::CpuProfiler::TimeRegionMap>& continuousData);
+
+            AZStd::vector<CpuProfilingStatisticsSerializerEntry> m_cpuProfilingStatisticsSerializerEntries;
+        };
+    }; // namespace RHI
 }; // namespace AZ
diff --git a/Gems/Atom/RHI/Code/Source/RHI/CpuProfilerImpl.cpp b/Gems/Atom/RHI/Code/Source/RHI/CpuProfilerImpl.cpp
index d41b5d656e..5585cc7032 100644
--- a/Gems/Atom/RHI/Code/Source/RHI/CpuProfilerImpl.cpp
+++ b/Gems/Atom/RHI/Code/Source/RHI/CpuProfilerImpl.cpp
@@ -409,5 +409,64 @@ namespace AZ
                 m_cachedTimeRegionMutex.unlock();
             }
         }
-    }
-}
+
+        // --- CpuProfilingStatisticsSerializer ---
+
+        CpuProfilingStatisticsSerializer::CpuProfilingStatisticsSerializer(const AZStd::ring_buffer<RHI::CpuProfiler::TimeRegionMap>& continuousData)
+        {
+            // Create serializable entries
+            for (const auto& timeRegionMap : continuousData)
+            {
+                for (const auto& threadEntry : timeRegionMap)
+                {
+                    for (const auto& cachedRegionEntry : threadEntry.second)
+                    {
+                        m_cpuProfilingStatisticsSerializerEntries.insert(
+                            m_cpuProfilingStatisticsSerializerEntries.end(),
+                            cachedRegionEntry.second.begin(),
+                            cachedRegionEntry.second.end());
+                    }
+                }
+            }
+        }
+
+        void CpuProfilingStatisticsSerializer::Reflect(AZ::ReflectContext* context)
+        {
+            if (auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
+            {
+                serializeContext->Class<CpuProfilingStatisticsSerializer>()
+                    ->Version(1)
+                    ->Field("cpuProfilingStatisticsSerializerEntries", &CpuProfilingStatisticsSerializer::m_cpuProfilingStatisticsSerializerEntries)
+                    ;
+            }
+
+            CpuProfilingStatisticsSerializerEntry::Reflect(context);
+        }
+
+        // --- CpuProfilingStatisticsSerializerEntry ---
+
+        CpuProfilingStatisticsSerializer::CpuProfilingStatisticsSerializerEntry::CpuProfilingStatisticsSerializerEntry(const RHI::CachedTimeRegion& cachedTimeRegion)
+        {
+            m_groupName = cachedTimeRegion.m_groupRegionName->m_groupName;
+            m_regionName = cachedTimeRegion.m_groupRegionName->m_regionName;
+            m_stackDepth = cachedTimeRegion.m_stackDepth;
+            m_startTick = cachedTimeRegion.m_startTick;
+            m_endTick = cachedTimeRegion.m_endTick;
+        }
+
+        void CpuProfilingStatisticsSerializer::CpuProfilingStatisticsSerializerEntry::Reflect(AZ::ReflectContext* context)
+        {
+            if (auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
+            {
+                serializeContext->Class<CpuProfilingStatisticsSerializerEntry>()
+                    ->Version(1)
+                    ->Field("groupName", &CpuProfilingStatisticsSerializerEntry::m_groupName)
+                    ->Field("regionName", &CpuProfilingStatisticsSerializerEntry::m_regionName)
+                    ->Field("stackDepth", &CpuProfilingStatisticsSerializerEntry::m_stackDepth)
+                    ->Field("startTick", &CpuProfilingStatisticsSerializerEntry::m_startTick)
+                    ->Field("endTick", &CpuProfilingStatisticsSerializerEntry::m_endTick)
+                    ;
+            }
+        }
+    } // namespace RHI
+} // namespace AZ
diff --git a/Gems/Atom/RPI/Code/Include/Atom/RPI.Edit/Common/JsonUtils.h b/Gems/Atom/RPI/Code/Include/Atom/RPI.Edit/Common/JsonUtils.h
index 3e3fbec8fe..549f787ac9 100644
--- a/Gems/Atom/RPI/Code/Include/Atom/RPI.Edit/Common/JsonUtils.h
+++ b/Gems/Atom/RPI/Code/Include/Atom/RPI.Edit/Common/JsonUtils.h
@@ -10,7 +10,9 @@
 
 #include <AzCore/JSON/document.h>
 #include <AzCore/Serialization/Json/JsonSerialization.h>
+
 #include <AtomCore/Serialization/Json/JsonUtils.h>
+
 #include <Atom/RPI.Edit/Common/JsonFileLoadContext.h>
 #include <Atom/RPI.Edit/Common/JsonReportingHelper.h>
 
@@ -118,7 +120,6 @@ namespace AZ
                 AZ_Error("AZ::RPI::JsonUtils", false, "Failed to load object from json string: %s", loadResult.GetError().c_str());
                 return false;
             }
-
         } // namespace JsonUtils
     } // namespace RPI
 } // namespace AZ
diff --git a/Gems/Atom/Utils/Code/Include/Atom/Utils/ImGuiCpuProfiler.h b/Gems/Atom/Utils/Code/Include/Atom/Utils/ImGuiCpuProfiler.h
index 75b7ec9fdd..bdaf38a64a 100644
--- a/Gems/Atom/Utils/Code/Include/Atom/Utils/ImGuiCpuProfiler.h
+++ b/Gems/Atom/Utils/Code/Include/Atom/Utils/ImGuiCpuProfiler.h
@@ -9,6 +9,7 @@
 #pragma once
 
 #include <AzCore/Component/TickBus.h>
+#include <AzCore/IO/Path/Path.h>
 #include <AzCore/Math/Random.h>
 
 #include <Atom/RHI.Reflect/CpuTimingStatistics.h>
@@ -102,6 +103,12 @@ namespace AZ
             //! Draws the statistical view of the CPU profiling data.
             void DrawStatisticsView();
 
+            //! Callback invoked when the "Load File" button is pressed in the file picker.
+            void LoadFile();
+
+            //! Draws the file picker window.
+            void DrawFilePicker();
+
             //! Draws the CPU profiling visualizer.
             void DrawVisualizer();
 
@@ -198,6 +205,14 @@ namespace AZ
             AZ::RHI::CpuTimingStatistics m_cpuTimingStatisticsWhenPause;
 
             AZStd::string m_lastCapturedFilePath;
+
+            bool m_showFilePicker = false;
+
+            // Cached file paths to previous traces on disk, sorted with the most recent trace at the front.
+            AZStd::vector<IO::Path> m_cachedCapturePaths;
+
+            // Index into the file picker, used to determine which file to load when "Load File" is pressed.
+            int m_currentFileIndex = 0;
         };
     } // namespace Render
 } // namespace AZ
diff --git a/Gems/Atom/Utils/Code/Include/Atom/Utils/ImGuiCpuProfiler.inl b/Gems/Atom/Utils/Code/Include/Atom/Utils/ImGuiCpuProfiler.inl
index a24fdbf1d8..9b4eebf043 100644
--- a/Gems/Atom/Utils/Code/Include/Atom/Utils/ImGuiCpuProfiler.inl
+++ b/Gems/Atom/Utils/Code/Include/Atom/Utils/ImGuiCpuProfiler.inl
@@ -9,9 +9,14 @@
 #include <Atom/Feature/Utils/ProfilingCaptureBus.h>
 #include <Atom/RHI.Reflect/CpuTimingStatistics.h>
 #include <Atom/RHI/CpuProfiler.h>
+#include <Atom/RHI/CpuProfilerImpl.h>
+#include <Atom/RPI.Edit/Common/JsonUtils.h>
 #include <Atom/RPI.Public/RPISystemInterface.h>
 
-#include <AzCore/IO/Path/Path_fwd.h>
+#include <AzCore/IO/FileIO.h>
+#include <AzCore/JSON/filereadstream.h>
+#include <AzCore/Serialization/Json/JsonSerialization.h>
+#include <AzCore/Serialization/Json/JsonSerializationResult.h>
 #include <AzCore/std/containers/map.h>
 #include <AzCore/std/containers/set.h>
 #include <AzCore/std/limits.h>
@@ -45,6 +50,74 @@ namespace AZ
                 AZ_Assert(ticksPerSecond >= 1000, "Error in converting ticks to ms, expected ticksPerSecond >= 1000");
                 return static_cast<float>((ticks * 1000) / (ticksPerSecond / 1000)) / 1000.0f;
             }
+
+            using DeserializedCpuData = AZStd::vector<RHI::CpuProfilingStatisticsSerializer::CpuProfilingStatisticsSerializerEntry>;
+            inline Outcome<DeserializedCpuData, AZStd::string> LoadSavedCpuProfilingStatistics(const AZStd::string& capturePath)
+            {
+                auto* base = IO::FileIOBase::GetInstance();
+
+                char resolvedPath[IO::MaxPathLength];
+                if (!base->ResolvePath(capturePath.c_str(), resolvedPath, IO::MaxPathLength))
+                {
+                    return Failure(AZStd::string::format("Could not resolve the path to file %s, is the path correct?", resolvedPath));
+                }
+
+                u64 captureSizeBytes;
+                const IO::Result fileSizeResult = base->Size(resolvedPath, captureSizeBytes);
+                if (!fileSizeResult)
+                {
+                    return Failure(AZStd::string::format("Could not read the size of file %s, is the path correct?", resolvedPath));
+                }
+
+                // NOTE: this uses raw file pointers over the abstractions and utility functions provided by AZ::JsonSerializationUtils because
+                // saved profiling captures can be upwards of 400 MB. This necessitates a buffered approach to avoid allocating huge chunks of memory.
+                FILE* fp = nullptr;
+                azfopen(&fp, resolvedPath, "rb");
+                if (!fp)
+                {
+                    return Failure(AZStd::string::format("Could not fopen file %s, is the path correct?\n", resolvedPath));
+                }
+
+                constexpr AZStd::size_t MaxBufSize = 65536;
+                const AZStd::size_t bufSize = AZStd::min(MaxBufSize, aznumeric_cast<AZStd::size_t>(captureSizeBytes));
+                char* buf = reinterpret_cast<char*>(azmalloc(bufSize));
+
+                rapidjson::Document document;
+                rapidjson::FileReadStream inputStream(fp, buf, bufSize);
+                document.ParseStream(inputStream);
+
+                azfree(buf);
+                fclose(fp);
+
+                if (document.HasParseError())
+                {
+                    const auto pe = document.GetParseError();
+                    return Failure(AZStd::string::format(
+                        "Rapidjson could not parse the document with ParseErrorCode %u. See 3rdParty/rapidjson/error.h for definitions.\n", pe));
+                }
+
+                if (!document.IsObject() || !document.HasMember("ClassData"))
+                {
+                    return Failure(AZStd::string::format(
+                        "Error in loading saved capture: top-level object does not have a ClassData field. Did the serialization format change recently?\n"));
+                }
+
+                AZ_TracePrintf("JsonUtils", "Successfully loaded JSON into memory.\n");
+
+                const auto& root = document["ClassData"];
+                RHI::CpuProfilingStatisticsSerializer serializer;
+                const JsonSerializationResult::ResultCode deserializationResult = JsonSerialization::Load(serializer, root);
+                if (deserializationResult.GetProcessing() == JsonSerializationResult::Processing::Halted
+                    || serializer.m_cpuProfilingStatisticsSerializerEntries.empty())
+                {
+                    return Failure(AZStd::string::format("Error in deserializing document: %s\n", deserializationResult.ToString(capturePath.c_str()).c_str()));
+                }
+
+                AZ_TracePrintf("JsonUtils", "Successfully loaded CPU profiling data with %zu profiling entries.\n",
+                     serializer.m_cpuProfilingStatisticsSerializerEntries.size());
+
+                return Success(AZStd::move(serializer.m_cpuProfilingStatisticsSerializerEntries));
+            }
         } // namespace CpuProfilerImGuiHelper
 
         inline void ImGuiCpuProfiler::Draw(bool& keepDrawing, const AZ::RHI::CpuTimingStatistics& currentCpuTimingStatistics)
@@ -80,6 +153,11 @@ namespace AZ
                 {
                     DrawStatisticsView();
                 }
+
+                if (m_showFilePicker)
+                {
+                    DrawFilePicker();
+                }
             }
             ImGui::End();
          
@@ -110,6 +188,11 @@ namespace AZ
 
         inline void ImGuiCpuProfiler::DrawCommonHeader()
         {
+            if (!m_lastCapturedFilePath.empty())
+            {
+                ImGui::Text("Saved: %s", m_lastCapturedFilePath.c_str());
+            }
+
             if (ImGui::Button(m_enableVisualizer ? "Swap to statistics" : "Swap to visualizer"))
             {
                 m_enableVisualizer = !m_enableVisualizer;
@@ -157,10 +240,31 @@ namespace AZ
                 }
             }
 
-            if (!m_lastCapturedFilePath.empty())
+            ImGui::SameLine();
+            if (ImGui::Button("Load file"))
             {
-                ImGui::SameLine();
-                ImGui::Text("Saved: %s", m_lastCapturedFilePath.c_str());
+                m_showFilePicker = true;
+
+                // Only update the cached file list when opened so that we aren't making IO calls on every frame.
+                auto* base = AZ::IO::FileIOBase::GetInstance();
+                const AZStd::string defaultSavedCapturePath = "@user@/CpuProfiler";
+
+                m_cachedCapturePaths.clear();
+                base->FindFiles(
+                    defaultSavedCapturePath.c_str(), "*.json",
+                    [&paths = m_cachedCapturePaths](const char* path) -> bool
+                    {
+                        auto foundPath = IO::Path(path);
+                        paths.push_back(foundPath);
+                        return true;
+                    });
+
+                // Sort by decreasing modification time (most recent at the top)
+                AZStd::sort(m_cachedCapturePaths.begin(), m_cachedCapturePaths.end(),
+                    [&base](const IO::Path& lhs, const IO::Path& rhs)
+                    {
+                        return base->ModificationTime(lhs.c_str()) > base->ModificationTime(rhs.c_str());
+                    });
             }
         }
 
@@ -313,6 +417,45 @@ namespace AZ
             } 
         }
 
+        inline void ImGuiCpuProfiler::DrawFilePicker()
+        {
+            ImGui::SetNextWindowSize({ 500, 200 }, ImGuiCond_Once);
+            if (ImGui::Begin("File Picker", &m_showFilePicker))
+            {
+                if (ImGui::Button("Load selected"))
+                {
+                    LoadFile();
+                }
+
+                auto getter = [](void* vectorPointer, int idx, const char** out_text) -> bool
+                {
+                    const auto& pathVec = *static_cast<AZStd::vector<IO::Path>*>(vectorPointer);
+                    if (idx < 0 || idx >= pathVec.size())
+                    {
+                        return false;
+                    }
+                    *out_text = pathVec[idx].c_str();
+                    return true;
+                };
+
+                ImGui::SetNextItemWidth(ImGui::GetWindowContentRegionWidth());
+                ImGui::ListBox("", &m_currentFileIndex, getter, &m_cachedCapturePaths, aznumeric_cast<int>(m_cachedCapturePaths.size()));
+            }
+            ImGui::End();
+        }
+
+        inline void ImGuiCpuProfiler::LoadFile()
+        {
+            const IO::Path& pathToLoad = m_cachedCapturePaths[m_currentFileIndex];
+            auto res = CpuProfilerImGuiHelper::LoadSavedCpuProfilingStatistics(pathToLoad.String());
+            if (!res.IsSuccess())
+            {
+                AZ_TracePrintf("ImGuiCpuProfiler", "%s", res.GetError().c_str());
+                return;
+            }
+            // TODO ATOM-16022 Parse this data and display it in the visualizer widget.
+        }
+
         // -- CPU Visualizer --
         inline void ImGuiCpuProfiler::DrawVisualizer()
         {

From fb05beffe3c7059f14e0a13f269b8e150ad25456 Mon Sep 17 00:00:00 2001
From: Esteban Papp <81431996+amznestebanpapp@users.noreply.github.com>
Date: Tue, 17 Aug 2021 12:05:51 -0700
Subject: [PATCH 11/37] Change LY_UNITY_BUILD default to "ON" (#3244)

Signed-off-by: Esteban Papp <81431996+amznestebanpapp@users.noreply.github.com>
---
 cmake/LYWrappers.cmake | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmake/LYWrappers.cmake b/cmake/LYWrappers.cmake
index e4398099d1..1a8e805f91 100644
--- a/cmake/LYWrappers.cmake
+++ b/cmake/LYWrappers.cmake
@@ -6,7 +6,7 @@
 #
 #
 
-set(LY_UNITY_BUILD OFF CACHE BOOL "UNITY builds")
+set(LY_UNITY_BUILD ON CACHE BOOL "UNITY builds")
 
 include(CMakeFindDependencyMacro)
 include(cmake/LyAutoGen.cmake)

From 401d0c1ad5e17a03409eb5267271ff6504df4f86 Mon Sep 17 00:00:00 2001
From: Junbo Liang <68558268+junbo75@users.noreply.github.com>
Date: Tue, 17 Aug 2021 15:17:48 -0700
Subject: [PATCH 12/37] Update the AWSNativeSDK version and hash for Mac
 (#3259)

---
 cmake/3rdParty/Platform/Mac/BuiltInPackages_mac.cmake | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmake/3rdParty/Platform/Mac/BuiltInPackages_mac.cmake b/cmake/3rdParty/Platform/Mac/BuiltInPackages_mac.cmake
index e66dfdaca1..a0001d3e4e 100644
--- a/cmake/3rdParty/Platform/Mac/BuiltInPackages_mac.cmake
+++ b/cmake/3rdParty/Platform/Mac/BuiltInPackages_mac.cmake
@@ -32,7 +32,7 @@ ly_associate_package(PACKAGE_NAME DirectXShaderCompilerDxc-1.6.2104-o3de-rev2-ma
 ly_associate_package(PACKAGE_NAME SPIRVCross-2021.04.29-rev1-mac                    TARGETS SPIRVCross                  PACKAGE_HASH 78c6376ed2fd195b9b1f5fb2b56e5267a32c3aa21fb399e905308de470eb4515)
 ly_associate_package(PACKAGE_NAME freetype-2.10.4.14-mac-ios                        TARGETS freetype                    PACKAGE_HASH 67b4f57aed92082d3fd7c16aa244a7d908d90122c296b0a63f73e0a0b8761977)
 ly_associate_package(PACKAGE_NAME tiff-4.2.0.15-mac-ios                             TARGETS tiff                        PACKAGE_HASH a23ae1f8991a29f8e5df09d6d5b00d7768a740f90752cef465558c1768343709)
-ly_associate_package(PACKAGE_NAME AWSNativeSDK-1.7.167-rev3-mac                     TARGETS AWSNativeSDK                PACKAGE_HASH 21920372e90355407578b45ac19580df1463a39a25a867bcd0ffd8b385c8254a)
+ly_associate_package(PACKAGE_NAME AWSNativeSDK-1.7.167-rev4-mac                     TARGETS AWSNativeSDK                PACKAGE_HASH 89e1651cde6b4e6bd80cdb96ed6b624accad9f9688ff38bfca226777f4fcb678)
 ly_associate_package(PACKAGE_NAME Lua-5.3.5-rev6-mac                                TARGETS Lua                         PACKAGE_HASH b9079fd35634774c9269028447562c6b712dbc83b9c64975c095fd423ff04c08)
 ly_associate_package(PACKAGE_NAME PhysX-4.1.2.29882248-rev3-mac                     TARGETS PhysX                       PACKAGE_HASH 5e092a11d5c0a50c4dd99bb681a04b566a4f6f29aa08443d9bffc8dc12c27c8e)
 ly_associate_package(PACKAGE_NAME etc2comp-9cd0f9cae0-rev1-mac                      TARGETS etc2comp                    PACKAGE_HASH 1966ab101c89db7ecf30984917e0a48c0d02ee0e4d65b798743842b9469c0818)

From 3e51240a05117c9573f91392e8ee4acecd3e9293 Mon Sep 17 00:00:00 2001
From: Shirang Jia <shiranj@amazon.com>
Date: Tue, 17 Aug 2021 15:25:32 -0700
Subject: [PATCH 13/37] Allow customized Jenkins parameters for different
 pipelines and add aws integration deployment pipeline (#3248)

Allow customized Jenkins parameters for different pipelines so that we can define different Jenkins parameters for a new pipeline and doesn't affect AR build parameters.

Add aws integration deployment pipeline.
---
 scripts/build/Jenkins/Jenkinsfile             | 34 +++++++++++++++++++
 .../build/Platform/Windows/build_config.json  |  5 +++
 scripts/build/Platform/Windows/pipeline.json  | 32 +++++++++++++++++
 3 files changed, 71 insertions(+)

diff --git a/scripts/build/Jenkins/Jenkinsfile b/scripts/build/Jenkins/Jenkinsfile
index 30efdc00ad..1c0409ceec 100644
--- a/scripts/build/Jenkins/Jenkinsfile
+++ b/scripts/build/Jenkins/Jenkinsfile
@@ -634,6 +634,40 @@ try {
                             pipelineParameters.add(booleanParam(defaultValue: true, description: '', name: platform.key))
                         }
                     }
+                    // Add additional Jenkins parameters
+                    pipelineConfig.platforms.each { platform ->
+                        platformEnv = platform.value.PIPELINE_ENV
+                        pipelineJenkinsParameters = platformEnv['PIPELINE_JENKINS_PARAMETERS'] ?: [:]
+                        jenkinsParametersToAdd = pipelineJenkinsParameters[pipelineName] ?: [:]
+                        jenkinsParametersToAdd.each{ jenkinsParameter ->
+                            defaultValue = jenkinsParameter['default_value']
+                            // Use last run's value as default value so we can save values in different Jenkins environment
+                            if (jenkinsParameter['use_last_run_value']?.toBoolean()) {
+                                defaultValue = params."$jenkinsParameter['parameter_name']" ?: jenkinsParameter['default_value']
+                            }
+                            switch (jenkinsParameter['parameter_type']) {
+                                case 'string':
+                                    pipelineParameters.add(stringParam(defaultValue: defaultValue,
+                                                                   description: jenkinsParameter['description'],
+                                                                   name: jenkinsParameter['parameter_name']
+                                                                   ))
+                                    break
+                                case 'boolean':
+                                    pipelineParameters.add(booleanParam(defaultValue: defaultValue,
+                                                                   description: jenkinsParameter['description'],
+                                                                   name: jenkinsParameter['parameter_name']
+                                                                   ))
+                                    break
+                                case 'password':
+                                    pipelineParameters.add(password(defaultValue: defaultValue,
+                                                                   description: jenkinsParameter['description'],
+                                                                   name: jenkinsParameter['parameter_name']
+                                                                   ))
+                                    break
+                            }
+                        }
+                    }
+
                     pipelineProperties.add(parameters(pipelineParameters))
                     properties(pipelineProperties)
 
diff --git a/scripts/build/Platform/Windows/build_config.json b/scripts/build/Platform/Windows/build_config.json
index 0268412aea..8928794a43 100644
--- a/scripts/build/Platform/Windows/build_config.json
+++ b/scripts/build/Platform/Windows/build_config.json
@@ -376,5 +376,10 @@
       "install_profile_vs2019",
       "project_engineinstall_profile_vs2019"
     ]
+  },
+  "awsi_deployment": {
+    "TAGS": ["awsi-deployment"],
+    "COMMAND": "deploy_cdk_applications.cmd",
+    "PARAMETERS": {}
   }
 }
diff --git a/scripts/build/Platform/Windows/pipeline.json b/scripts/build/Platform/Windows/pipeline.json
index 622fa9d5ae..4cfc6f696a 100644
--- a/scripts/build/Platform/Windows/pipeline.json
+++ b/scripts/build/Platform/Windows/pipeline.json
@@ -16,5 +16,37 @@
         "nightly-clean": {
             "CLEAN_WORKSPACE": true
         }
+    },
+    "PIPELINE_JENKINS_PARAMETERS": {
+        "awsi-deployment": [
+            {
+                "parameter_name": "O3DE_AWS_PROJECT_NAME",
+                "parameter_type": "string",
+                "default_value": "",
+                "use_last_run_value": true,
+                "description": ""
+            },
+            {
+                "parameter_name": "O3DE_AWS_DEPLOY_REGION",
+                "parameter_type": "string",
+                "default_value": "",
+                "use_last_run_value": true,
+                "description": ""
+            },
+            {
+                "parameter_name": "ASSUME_ROLE_ARN",
+                "parameter_type": "string",
+                "default_value": "",
+                "use_last_run_value": true,
+                "description": ""
+            },
+            {
+                "parameter_name": "COMMIT_ID",
+                "parameter_type": "string",
+                "default_value": "",
+                "use_last_run_value": true,
+                "description": ""
+            }
+        ]
     }
 }
\ No newline at end of file

From 078e0a86938699d3fce2c44027540cc5637f5735 Mon Sep 17 00:00:00 2001
From: amzn-phist <52085794+amzn-phist@users.noreply.github.com>
Date: Tue, 17 Aug 2021 17:59:09 -0500
Subject: [PATCH 14/37] Audio legacy cleanup - Move global functions to be
 handled by AudioSystemComponent (#3283)

* Removes legacy audio listener updates from ViewSys

These functions were empty and logging a warning, removed.

Signed-off-by: amzn-phist <52085794+amzn-phist@users.noreply.github.com>

* Move more audio functions to AudioSystemComponent

For global actions like Mute/Unmute, Reload, StopAll, Load/Unload Level,
we move those functions to be handled by the AudioSystemComponent in
LmbrCentral.  This lets us remove some includes of IAudioSystem.h from
Editor and Legacy/CrySystem.

There were several locations where audio banks were being loaded and
unloaded for a level.  Now they all call into the AudioSystemComponent
and we don't have multiple copies of the same code.

Signed-off-by: amzn-phist <52085794+amzn-phist@users.noreply.github.com>
---
 Code/Editor/CryEditDoc.cpp                    |  50 +------
 Code/Editor/MainWindow.cpp                    |  20 ++-
 Code/Editor/ViewportTitleDlg.cpp              |  41 ++++--
 Code/Editor/ViewportTitleDlg.h                |   8 -
 Code/Legacy/CryCommon/IViewSystem.h           |   3 -
 .../CrySystem/LevelSystem/LevelSystem.cpp     |  52 -------
 .../LevelSystem/SpawnableLevelSystem.cpp      |  58 --------
 Code/Legacy/CrySystem/System.cpp              |  18 ---
 .../CrySystem/ViewSystem/DebugCamera.cpp      |   6 -
 Code/Legacy/CrySystem/ViewSystem/View.cpp     |   5 -
 Code/Legacy/CrySystem/ViewSystem/View.h       |   1 -
 .../CrySystem/ViewSystem/ViewSystem.cpp       |  11 --
 Code/Legacy/CrySystem/ViewSystem/ViewSystem.h |   2 -
 .../Source/Audio/AudioSystemComponent.cpp     | 138 ++++++++++++++++--
 .../Code/Source/Audio/AudioSystemComponent.h  |  13 ++
 .../Audio/AudioSystemComponentBus.h           |  11 ++
 .../Code/Source/Animation/AzEntityNode.cpp    |   1 -
 17 files changed, 192 insertions(+), 246 deletions(-)

diff --git a/Code/Editor/CryEditDoc.cpp b/Code/Editor/CryEditDoc.cpp
index c720299ce8..90b020f452 100644
--- a/Code/Editor/CryEditDoc.cpp
+++ b/Code/Editor/CryEditDoc.cpp
@@ -32,9 +32,6 @@
 #include <AzToolsFramework/API/EditorLevelNotificationBus.h>
 #include <AzToolsFramework/Entity/PrefabEditorEntityOwnershipInterface.h>
 
-// CryCommon
-#include <CryCommon/IAudioSystem.h>
-
 // Editor
 #include "Settings.h"
 
@@ -60,6 +57,7 @@
 #include <Atom/RPI.Public/ViewportContextBus.h>
 
 // LmbrCentral
+#include <LmbrCentral/Audio/AudioSystemComponentBus.h>
 #include <LmbrCentral/Rendering/EditorLightComponentBus.h> // for LmbrCentral::EditorLightComponentRequestBus
 
 //#define PROFILE_LOADING_WITH_VTUNE
@@ -269,20 +267,7 @@ void CCryEditDoc::DeleteContents()
     CErrorReportDialog::Clear();
 
     // Unload level specific audio binary data.
-    Audio::SAudioManagerRequestData<Audio::eAMRT_UNLOAD_AFCM_DATA_BY_SCOPE> oAMData(Audio::eADS_LEVEL_SPECIFIC);
-    Audio::SAudioRequest oAudioRequestData;
-    oAudioRequestData.nFlags = (Audio::eARF_PRIORITY_HIGH | Audio::eARF_EXECUTE_BLOCKING);
-    oAudioRequestData.pData = &oAMData;
-    Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::PushRequestBlocking, oAudioRequestData);
-
-    // Now unload level specific audio config data.
-    Audio::SAudioManagerRequestData<Audio::eAMRT_CLEAR_CONTROLS_DATA> oAMData2(Audio::eADS_LEVEL_SPECIFIC);
-    oAudioRequestData.pData = &oAMData2;
-    Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::PushRequestBlocking, oAudioRequestData);
-
-    Audio::SAudioManagerRequestData<Audio::eAMRT_CLEAR_PRELOADS_DATA> oAMData3(Audio::eADS_LEVEL_SPECIFIC);
-    oAudioRequestData.pData = &oAMData3;
-    Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::PushRequestBlocking, oAudioRequestData);
+    LmbrCentral::AudioSystemComponentRequestBus::Broadcast(&LmbrCentral::AudioSystemComponentRequestBus::Events::LevelUnloadAudio);
 
     GetIEditor()->Notify(eNotify_OnSceneClosed);
     CrySystemEventBus::Broadcast(&CrySystemEventBus::Events::OnCryEditorSceneClosed);
@@ -413,32 +398,11 @@ void CCryEditDoc::Load(TDocMultiArchive& arrXmlAr, const QString& szFilename)
 #ifdef PROFILE_LOADING_WITH_VTUNE
         VTResume();
 #endif
-        // Parse level specific config data.
-        const char* controlsPath = nullptr;
-        Audio::AudioSystemRequestBus::BroadcastResult(controlsPath, &Audio::AudioSystemRequestBus::Events::GetControlsPath);
-        QString sAudioLevelPath(controlsPath);
-        sAudioLevelPath += "levels/";
-        AZStd::string const sLevelNameOnly = PathUtil::GetFileName(fileName.toUtf8().data());
-        sAudioLevelPath += sLevelNameOnly.c_str();
-        QByteArray path = sAudioLevelPath.toUtf8();
-        Audio::SAudioManagerRequestData<Audio::eAMRT_PARSE_CONTROLS_DATA> oAMData(path, Audio::eADS_LEVEL_SPECIFIC);
-        Audio::SAudioRequest oAudioRequestData;
-        oAudioRequestData.nFlags = (Audio::eARF_PRIORITY_HIGH | Audio::eARF_EXECUTE_BLOCKING); // Needs to be blocking so data is available for next preloading request!
-        oAudioRequestData.pData = &oAMData;
-        Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::PushRequestBlocking, oAudioRequestData);
-
-        Audio::SAudioManagerRequestData<Audio::eAMRT_PARSE_PRELOADS_DATA> oAMData2(path, Audio::eADS_LEVEL_SPECIFIC);
-        oAudioRequestData.pData = &oAMData2;
-        Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::PushRequestBlocking, oAudioRequestData);
-
-        Audio::TAudioPreloadRequestID nPreloadRequestID = INVALID_AUDIO_PRELOAD_REQUEST_ID;
-        Audio::AudioSystemRequestBus::BroadcastResult(nPreloadRequestID, &Audio::AudioSystemRequestBus::Events::GetAudioPreloadRequestID, sLevelNameOnly.c_str());
-        if (nPreloadRequestID != INVALID_AUDIO_PRELOAD_REQUEST_ID)
-        {
-            Audio::SAudioManagerRequestData<Audio::eAMRT_PRELOAD_SINGLE_REQUEST> oAMData3(nPreloadRequestID);
-            oAudioRequestData.pData = &oAMData3;
-            Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::PushRequestBlocking, oAudioRequestData);
-        }
+        // Load level-specific audio data.
+        AZStd::string levelFileName{ fileName.toUtf8().constData() };
+        AZStd::to_lower(levelFileName.begin(), levelFileName.end());
+        LmbrCentral::AudioSystemComponentRequestBus::Broadcast(
+            &LmbrCentral::AudioSystemComponentRequestBus::Events::LevelLoadAudio, AZStd::string_view{ levelFileName });
 
         {
             CAutoLogTime logtime("Game Engine level load");
diff --git a/Code/Editor/MainWindow.cpp b/Code/Editor/MainWindow.cpp
index bb246c2337..9560fd0fe7 100644
--- a/Code/Editor/MainWindow.cpp
+++ b/Code/Editor/MainWindow.cpp
@@ -97,6 +97,7 @@ AZ_POP_DISABLE_WARNING
 #include "ActionManager.h"
 
 #include <ImGuiBus.h>
+#include <LmbrCentral/Audio/AudioSystemComponentBus.h>
 
 using namespace AZ;
 using namespace AzQtComponents;
@@ -1474,25 +1475,22 @@ int MainWindow::ViewPaneVersion() const
 
 void MainWindow::OnStopAllSounds()
 {
-    Audio::SAudioRequest oStopAllSoundsRequest;
-    Audio::SAudioManagerRequestData<Audio::eAMRT_STOP_ALL_SOUNDS>   oStopAllSoundsRequestData;
-    oStopAllSoundsRequest.pData = &oStopAllSoundsRequestData;
-
-    CryLogAlways("<Audio> Executed \"Stop All Sounds\" command.");
-    Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::PushRequest, oStopAllSoundsRequest);
+    LmbrCentral::AudioSystemComponentRequestBus::Broadcast(&LmbrCentral::AudioSystemComponentRequestBus::Events::GlobalStopAllSounds);
 }
 
 void MainWindow::OnRefreshAudioSystem()
 {
-    QString sLevelName = GetIEditor()->GetGameEngine()->GetLevelName();
+    AZStd::string levelName;
+    AzToolsFramework::EditorRequestBus::BroadcastResult(levelName, &AzToolsFramework::EditorRequestBus::Events::GetLevelName);
+    AZStd::to_lower(levelName.begin(), levelName.end());
 
-    if (QString::compare(sLevelName, "Untitled", Qt::CaseInsensitive) == 0)
+    if (levelName == "untitled")
     {
-        // Rather pass nullptr to indicate that no level is loaded!
-        sLevelName = QString();
+        levelName.clear();
     }
 
-    Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::RefreshAudioSystem, sLevelName.toUtf8().data());
+    LmbrCentral::AudioSystemComponentRequestBus::Broadcast(
+        &LmbrCentral::AudioSystemComponentRequestBus::Events::GlobalRefreshAudio, AZStd::string_view{ levelName });
 }
 
 void MainWindow::SaveLayout()
diff --git a/Code/Editor/ViewportTitleDlg.cpp b/Code/Editor/ViewportTitleDlg.cpp
index f5515b9c18..eacf01a6fe 100644
--- a/Code/Editor/ViewportTitleDlg.cpp
+++ b/Code/Editor/ViewportTitleDlg.cpp
@@ -43,6 +43,8 @@
 #include <AzCore/Casting/numeric_cast.h>
 #include <AzToolsFramework/Viewport/ViewportMessages.h>
 
+#include <LmbrCentral/Audio/AudioSystemComponentBus.h>
+
 AZ_PUSH_DISABLE_DLL_EXPORT_MEMBER_WARNING
 #include "ui_ViewportTitleDlg.h"
 AZ_POP_DISABLE_DLL_EXPORT_MEMBER_WARNING
@@ -119,17 +121,20 @@ CViewportTitleDlg::CViewportTitleDlg(QWidget* pParent)
     LoadCustomPresets("AspectRatioPresets", "AspectRatioPreset", m_customAspectRatioPresets);
     LoadCustomPresets("ResPresets", "ResPreset", m_customResPresets);
 
-    // audio request setup
-    m_oMuteAudioRequest.pData = &m_oMuteAudioRequestData;
-    m_oUnmuteAudioRequest.pData = &m_oUnmuteAudioRequestData;
-
     SetupCameraDropdownMenu();
     SetupResolutionDropdownMenu();
     SetupViewportInformationMenu();
     SetupHelpersButton();
     SetupOverflowMenu();
 
-    Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::PushRequest, gSettings.bMuteAudio ? m_oMuteAudioRequest : m_oUnmuteAudioRequest);
+    if (gSettings.bMuteAudio)
+    {
+        LmbrCentral::AudioSystemComponentRequestBus::Broadcast(&LmbrCentral::AudioSystemComponentRequestBus::Events::GlobalMuteAudio);
+    }
+    else
+    {
+        LmbrCentral::AudioSystemComponentRequestBus::Broadcast(&LmbrCentral::AudioSystemComponentRequestBus::Events::GlobalUnmuteAudio);
+    }
 
     connect(this, &CViewportTitleDlg::ActionTriggered, MainWindow::instance()->GetActionManager(), &ActionManager::ActionTriggered);
 
@@ -877,25 +882,33 @@ void CViewportTitleDlg::OnBnClickedGotoPosition()
 void CViewportTitleDlg::OnBnClickedMuteAudio()
 {
     gSettings.bMuteAudio = !gSettings.bMuteAudio;
-
-    Audio::AudioSystemRequestBus::Broadcast(
-        &Audio::AudioSystemRequestBus::Events::PushRequest, gSettings.bMuteAudio ? m_oMuteAudioRequest : m_oUnmuteAudioRequest);
+    if (gSettings.bMuteAudio)
+    {
+        LmbrCentral::AudioSystemComponentRequestBus::Broadcast(&LmbrCentral::AudioSystemComponentRequestBus::Events::GlobalMuteAudio);
+    }
+    else
+    {
+        LmbrCentral::AudioSystemComponentRequestBus::Broadcast(&LmbrCentral::AudioSystemComponentRequestBus::Events::GlobalUnmuteAudio);
+    }
 
     UpdateMuteActionText();
 }
 
 void CViewportTitleDlg::UpdateMuteActionText()
 {
-    if (!Audio::AudioSystemRequestBus::HasHandlers())
-    {
-        m_audioMuteAction->setEnabled(false);
-        m_audioMuteAction->setText(tr("Mute Audio: Enable Audio Gem"));
-    }
-    else
+    bool audioSystemConnected = false;
+    LmbrCentral::AudioSystemComponentRequestBus::BroadcastResult(
+        audioSystemConnected, &LmbrCentral::AudioSystemComponentRequestBus::Events::IsAudioSystemInitialized);
+    if (audioSystemConnected)
     {
         m_audioMuteAction->setEnabled(true);
         m_audioMuteAction->setText(gSettings.bMuteAudio ? tr("Un-mute Audio") : tr("Mute Audio"));
     }
+    else
+    {
+        m_audioMuteAction->setEnabled(false);
+        m_audioMuteAction->setText(tr("Mute Audio: Enable Audio Gem"));
+    }
 }
 
 void CViewportTitleDlg::OnHMDInitialized()
diff --git a/Code/Editor/ViewportTitleDlg.h b/Code/Editor/ViewportTitleDlg.h
index 8a1766a764..5acb04ca99 100644
--- a/Code/Editor/ViewportTitleDlg.h
+++ b/Code/Editor/ViewportTitleDlg.h
@@ -14,8 +14,6 @@
 #if !defined(Q_MOC_RUN)
 #include <AzCore/Component/Component.h>
 
-#include <IAudioSystem.h>
-
 #include <functional>
 #include <QSharedPointer>
 #include <QWidgetAction>
@@ -178,12 +176,6 @@ protected:
     QWidgetAction* m_gridSizeActionWidget = nullptr;
     QWidgetAction* m_angleSizeActionWidget = nullptr;
 
-    Audio::SAudioRequest m_oMuteAudioRequest;
-    Audio::SAudioManagerRequestData<Audio::eAMRT_MUTE_ALL> m_oMuteAudioRequestData;
-    Audio::SAudioRequest m_oUnmuteAudioRequest;
-    Audio::SAudioManagerRequestData<Audio::eAMRT_UNMUTE_ALL> m_oUnmuteAudioRequestData;
-
-
     QScopedPointer<Ui::ViewportTitleDlg> m_ui;
 };
 
diff --git a/Code/Legacy/CryCommon/IViewSystem.h b/Code/Legacy/CryCommon/IViewSystem.h
index d1c0a040df..583c0982c9 100644
--- a/Code/Legacy/CryCommon/IViewSystem.h
+++ b/Code/Legacy/CryCommon/IViewSystem.h
@@ -246,7 +246,6 @@ struct IView
     virtual void SetScale(const float scale) = 0;
     virtual void SetZoomedScale(const float scale) = 0;
     virtual void SetActive(const bool bActive) = 0;
-    virtual void UpdateAudioListener(const Matrix34& rMatrix) = 0;
 };
 
 struct IViewSystemListener
@@ -295,8 +294,6 @@ struct IViewSystem
 
     virtual bool IsPlayingCutScene() const = 0;
 
-    virtual void UpdateSoundListeners() = 0;
-
     virtual void SetDeferredViewSystemUpdate(bool const bDeferred) = 0;
     virtual bool UseDeferredViewSystemUpdate() const = 0;
     virtual void SetControlAudioListeners(bool const bActive) = 0;
diff --git a/Code/Legacy/CrySystem/LevelSystem/LevelSystem.cpp b/Code/Legacy/CrySystem/LevelSystem/LevelSystem.cpp
index ee747bc936..bb2f36e69c 100644
--- a/Code/Legacy/CrySystem/LevelSystem/LevelSystem.cpp
+++ b/Code/Legacy/CrySystem/LevelSystem/LevelSystem.cpp
@@ -11,7 +11,6 @@
 
 #include "CrySystem_precompiled.h"
 #include "LevelSystem.h"
-#include <IAudioSystem.h>
 #include "IMovieSystem.h"
 #include <ILocalizationManager.h>
 #include "CryPath.h"
@@ -630,41 +629,6 @@ ILevel* CLevelSystem::LoadLevelInternal(const char* _levelName)
             pSpamDelay->Set(0.0f);
         }
 
-        // Parse level specific config data.
-        AZStd::string const sLevelNameOnly(PathUtil::GetFileName(levelName));
-
-        if (!sLevelNameOnly.empty())
-        {
-            const char* controlsPath = nullptr;
-            Audio::AudioSystemRequestBus::BroadcastResult(controlsPath, &Audio::AudioSystemRequestBus::Events::GetControlsPath);
-            if (controlsPath)
-            {
-                AZStd::string sAudioLevelPath(controlsPath);
-                sAudioLevelPath.append("levels/");
-                sAudioLevelPath += sLevelNameOnly;
-
-                Audio::SAudioManagerRequestData<Audio::eAMRT_PARSE_CONTROLS_DATA> oAMData(sAudioLevelPath.c_str(), Audio::eADS_LEVEL_SPECIFIC);
-                Audio::SAudioRequest oAudioRequestData;
-                oAudioRequestData.nFlags = (Audio::eARF_PRIORITY_HIGH | Audio::eARF_EXECUTE_BLOCKING); // Needs to be blocking so data is available for next preloading request!
-                oAudioRequestData.pData = &oAMData;
-                Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::PushRequestBlocking, oAudioRequestData);
-
-                Audio::SAudioManagerRequestData<Audio::eAMRT_PARSE_PRELOADS_DATA> oAMData2(sAudioLevelPath.c_str(), Audio::eADS_LEVEL_SPECIFIC);
-                oAudioRequestData.pData = &oAMData2;
-                Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::PushRequestBlocking, oAudioRequestData);
-
-                Audio::TAudioPreloadRequestID nPreloadRequestID = INVALID_AUDIO_PRELOAD_REQUEST_ID;
-
-                Audio::AudioSystemRequestBus::BroadcastResult(nPreloadRequestID, &Audio::AudioSystemRequestBus::Events::GetAudioPreloadRequestID, sLevelNameOnly.c_str());
-                if (nPreloadRequestID != INVALID_AUDIO_PRELOAD_REQUEST_ID)
-                {
-                    Audio::SAudioManagerRequestData<Audio::eAMRT_PRELOAD_SINGLE_REQUEST> requestData(nPreloadRequestID, true);
-                    oAudioRequestData.pData = &requestData;
-                    Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::PushRequestBlocking, oAudioRequestData);
-                }
-            }
-        }
-
         {
             AZStd::string missionXml("Mission_");
             missionXml += pLevelInfo->m_defaultGameTypeName;
@@ -926,22 +890,6 @@ void CLevelSystem::UnloadLevel()
         gEnv->pMovieSystem->RemoveAllSequences();
     }
 
-    // Unload level specific audio binary data.
-    Audio::SAudioManagerRequestData<Audio::eAMRT_UNLOAD_AFCM_DATA_BY_SCOPE> oAMData(Audio::eADS_LEVEL_SPECIFIC);
-    Audio::SAudioRequest oAudioRequestData;
-    oAudioRequestData.nFlags = (Audio::eARF_PRIORITY_HIGH | Audio::eARF_EXECUTE_BLOCKING);
-    oAudioRequestData.pData = &oAMData;
-    Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::PushRequestBlocking, oAudioRequestData);
-
-    // Now unload level specific audio config data.
-    Audio::SAudioManagerRequestData<Audio::eAMRT_CLEAR_CONTROLS_DATA> oAMData2(Audio::eADS_LEVEL_SPECIFIC);
-    oAudioRequestData.pData = &oAMData2;
-    Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::PushRequestBlocking, oAudioRequestData);
-
-    Audio::SAudioManagerRequestData<Audio::eAMRT_CLEAR_PRELOADS_DATA> oAMData3(Audio::eADS_LEVEL_SPECIFIC);
-    oAudioRequestData.pData = &oAMData3;
-    Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::PushRequestBlocking, oAudioRequestData);
-
     OnUnloadComplete(m_lastLevelName.c_str());
 
     // -- kenzo: this will close all pack files for this level
diff --git a/Code/Legacy/CrySystem/LevelSystem/SpawnableLevelSystem.cpp b/Code/Legacy/CrySystem/LevelSystem/SpawnableLevelSystem.cpp
index f541ad1cec..b37b257f5b 100644
--- a/Code/Legacy/CrySystem/LevelSystem/SpawnableLevelSystem.cpp
+++ b/Code/Legacy/CrySystem/LevelSystem/SpawnableLevelSystem.cpp
@@ -8,7 +8,6 @@
 
 #include "CrySystem_precompiled.h"
 #include "SpawnableLevelSystem.h"
-#include <IAudioSystem.h>
 #include "IMovieSystem.h"
 
 #include <LoadScreenBus.h>
@@ -280,47 +279,6 @@ namespace LegacyLevelSystem
                 pSpamDelay->Set(0.0f);
             }
 
-            // Parse level specific config data.
-            AZStd::string const sLevelNameOnly(PathUtil::GetFileName(levelName));
-
-            if (!sLevelNameOnly.empty())
-            {
-                const char* controlsPath = nullptr;
-                Audio::AudioSystemRequestBus::BroadcastResult(controlsPath, &Audio::AudioSystemRequestBus::Events::GetControlsPath);
-                if (controlsPath)
-                {
-                    AZStd::string sAudioLevelPath(controlsPath);
-                    sAudioLevelPath.append("levels/");
-                    sAudioLevelPath += sLevelNameOnly;
-
-                    Audio::SAudioManagerRequestData<Audio::eAMRT_PARSE_CONTROLS_DATA> oAMData(
-                        sAudioLevelPath.c_str(), Audio::eADS_LEVEL_SPECIFIC);
-                    Audio::SAudioRequest oAudioRequestData;
-                    oAudioRequestData.nFlags =
-                        (Audio::eARF_PRIORITY_HIGH |
-                         Audio::eARF_EXECUTE_BLOCKING); // Needs to be blocking so data is available for next preloading request!
-                    oAudioRequestData.pData = &oAMData;
-                    Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::PushRequestBlocking, oAudioRequestData);
-
-                    Audio::SAudioManagerRequestData<Audio::eAMRT_PARSE_PRELOADS_DATA> oAMData2(
-                        sAudioLevelPath.c_str(), Audio::eADS_LEVEL_SPECIFIC);
-                    oAudioRequestData.pData = &oAMData2;
-                    Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::PushRequestBlocking, oAudioRequestData);
-
-                    Audio::TAudioPreloadRequestID nPreloadRequestID = INVALID_AUDIO_PRELOAD_REQUEST_ID;
-
-                    Audio::AudioSystemRequestBus::BroadcastResult(
-                        nPreloadRequestID, &Audio::AudioSystemRequestBus::Events::GetAudioPreloadRequestID, sLevelNameOnly.c_str());
-                    if (nPreloadRequestID != INVALID_AUDIO_PRELOAD_REQUEST_ID)
-                    {
-                        Audio::SAudioManagerRequestData<Audio::eAMRT_PRELOAD_SINGLE_REQUEST> requestData(nPreloadRequestID, true);
-                        oAudioRequestData.pData = &requestData;
-                        Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::PushRequestBlocking, oAudioRequestData);
-                    }
-                }
-            }
-
-
             AZ::Data::Asset<AzFramework::Spawnable> rootSpawnable(
                 rootSpawnableAssetId, azrtti_typeid<AzFramework::Spawnable>(), levelName);
 
@@ -565,22 +523,6 @@ namespace LegacyLevelSystem
             gEnv->pMovieSystem->RemoveAllSequences();
         }
 
-        // Unload level specific audio binary data.
-        Audio::SAudioManagerRequestData<Audio::eAMRT_UNLOAD_AFCM_DATA_BY_SCOPE> oAMData(Audio::eADS_LEVEL_SPECIFIC);
-        Audio::SAudioRequest oAudioRequestData;
-        oAudioRequestData.nFlags = (Audio::eARF_PRIORITY_HIGH | Audio::eARF_EXECUTE_BLOCKING);
-        oAudioRequestData.pData = &oAMData;
-        Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::PushRequestBlocking, oAudioRequestData);
-
-        // Now unload level specific audio config data.
-        Audio::SAudioManagerRequestData<Audio::eAMRT_CLEAR_CONTROLS_DATA> oAMData2(Audio::eADS_LEVEL_SPECIFIC);
-        oAudioRequestData.pData = &oAMData2;
-        Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::PushRequestBlocking, oAudioRequestData);
-
-        Audio::SAudioManagerRequestData<Audio::eAMRT_CLEAR_PRELOADS_DATA> oAMData3(Audio::eADS_LEVEL_SPECIFIC);
-        oAudioRequestData.pData = &oAMData3;
-        Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::PushRequestBlocking, oAudioRequestData);
-
         OnUnloadComplete(m_lastLevelName.c_str());
 
         AzFramework::RootSpawnableInterface::Get()->ReleaseRootSpawnable();
diff --git a/Code/Legacy/CrySystem/System.cpp b/Code/Legacy/CrySystem/System.cpp
index 8c42c4a027..3673088695 100644
--- a/Code/Legacy/CrySystem/System.cpp
+++ b/Code/Legacy/CrySystem/System.cpp
@@ -892,24 +892,6 @@ bool CSystem::UpdatePreTickBus(int updateFlags, int nPauseMode)
         return false;
     }
 
-       //////////////////////////////////////////////////////////////////////
-       //update sound system Part 1 if in Editor / in Game Mode Viewsystem updates the Listeners
-    if (!m_env.IsEditorGameMode())
-    {
-        if ((updateFlags & ESYSUPDATE_EDITOR) != 0 && !bNoUpdate && nPauseMode != 1)
-        {
-            // updating the Listener Position in a first separate step.
-            // Updating all views here is a bit of a workaround, since we need
-            // to ensure that sound listeners owned by inactive views are also
-            // marked as inactive. Ideally that should happen when exiting game mode.
-            if (GetIViewSystem())
-            {
-                FRAME_PROFILER("SysUpdate:UpdateSoundListeners", this, PROFILE_SYSTEM);
-                GetIViewSystem()->UpdateSoundListeners();
-            }
-        }
-    }
-
     // Use UI timer for CryMovie, because it should not be affected by pausing game time
     const float fMovieFrameTime = m_Time.GetFrameTime(ITimer::ETIMER_UI);
 
diff --git a/Code/Legacy/CrySystem/ViewSystem/DebugCamera.cpp b/Code/Legacy/CrySystem/ViewSystem/DebugCamera.cpp
index 1616816844..6eab555ac4 100644
--- a/Code/Legacy/CrySystem/ViewSystem/DebugCamera.cpp
+++ b/Code/Legacy/CrySystem/ViewSystem/DebugCamera.cpp
@@ -115,12 +115,6 @@ void DebugCamera::Update()
 
     m_view = Matrix33(Ang3(DEG2RAD(m_cameraPitch), 0.0f, DEG2RAD(m_cameraYaw)));
     UpdatePosition(m_moveInput);
-
-    // update the listener of the active view
-    if (IView* view = gEnv->pSystem->GetIViewSystem()->GetActiveView())
-    {
-        view->UpdateAudioListener(Matrix34(m_view, m_position));
-    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/Code/Legacy/CrySystem/ViewSystem/View.cpp b/Code/Legacy/CrySystem/ViewSystem/View.cpp
index d8dc24123c..7b3883f014 100644
--- a/Code/Legacy/CrySystem/ViewSystem/View.cpp
+++ b/Code/Legacy/CrySystem/ViewSystem/View.cpp
@@ -553,11 +553,6 @@ void CView::PostSerialize()
 {
 }
 
-//////////////////////////////////////////////////////////////////////////
-void CView::UpdateAudioListener([[maybe_unused]] Matrix34 const& rMatrix)
-{
-}
-
 //////////////////////////////////////////////////////////////////////////
 void CView::SetActive([[maybe_unused]] bool const bActive)
 {
diff --git a/Code/Legacy/CrySystem/ViewSystem/View.h b/Code/Legacy/CrySystem/ViewSystem/View.h
index 9fb13caadf..58d7e64869 100644
--- a/Code/Legacy/CrySystem/ViewSystem/View.h
+++ b/Code/Legacy/CrySystem/ViewSystem/View.h
@@ -110,7 +110,6 @@ public:
     void PostSerialize() override;
     CCamera& GetCamera() override { return m_camera; }
     const CCamera& GetCamera() const override { return m_camera; }
-    void UpdateAudioListener(const Matrix34& rMatrix) override;
 
     void GetMemoryUsage(ICrySizer* s) const;
 
diff --git a/Code/Legacy/CrySystem/ViewSystem/ViewSystem.cpp b/Code/Legacy/CrySystem/ViewSystem/ViewSystem.cpp
index c5df4f6570..6d2d393a11 100644
--- a/Code/Legacy/CrySystem/ViewSystem/ViewSystem.cpp
+++ b/Code/Legacy/CrySystem/ViewSystem/ViewSystem.cpp
@@ -200,11 +200,6 @@ void CViewSystem::Update(float frameTime)
         if (bIsActive)
         {
             CCamera& rCamera = pView->GetCamera();
-            if (!s_debugCamera || !s_debugCamera->IsEnabled())
-            {
-                pView->UpdateAudioListener(rCamera.GetMatrix());
-            }
-
             if (const SViewParams* currentParams = pView->GetCurrentParams())
             {
                 SViewParams copyCurrentParams = *currentParams;
@@ -554,12 +549,6 @@ void CViewSystem::SetOverrideCameraRotation(bool bOverride, Quat rotation)
     m_overridenCameraRotation = rotation;
 }
 
-//////////////////////////////////////////////////////////////////////////
-void CViewSystem::UpdateSoundListeners()
-{
-    AZ_ErrorOnce("CryLegacy", false, "CryLegacy view system no longer available (CViewSystem::UpdateSoundListeners)");
-}
-
 //////////////////////////////////////////////////////////////////
 void CViewSystem::OnLoadingStart([[maybe_unused]] const char* levelName)
 {
diff --git a/Code/Legacy/CrySystem/ViewSystem/ViewSystem.h b/Code/Legacy/CrySystem/ViewSystem/ViewSystem.h
index 61bb689554..644a197e46 100644
--- a/Code/Legacy/CrySystem/ViewSystem/ViewSystem.h
+++ b/Code/Legacy/CrySystem/ViewSystem/ViewSystem.h
@@ -65,8 +65,6 @@ public:
     {
         return m_cutsceneCount > 0;
     }
-    virtual void UpdateSoundListeners();
-
     virtual void SetDeferredViewSystemUpdate(bool const bDeferred){ m_useDeferredViewSystemUpdate = bDeferred; }
     virtual bool UseDeferredViewSystemUpdate() const { return m_useDeferredViewSystemUpdate; }
     virtual void SetControlAudioListeners(bool const bActive);
diff --git a/Gems/LmbrCentral/Code/Source/Audio/AudioSystemComponent.cpp b/Gems/LmbrCentral/Code/Source/Audio/AudioSystemComponent.cpp
index b12146af3a..cd4cff09ae 100644
--- a/Gems/LmbrCentral/Code/Source/Audio/AudioSystemComponent.cpp
+++ b/Gems/LmbrCentral/Code/Source/Audio/AudioSystemComponent.cpp
@@ -15,7 +15,10 @@
 
 #include <LmbrCentral/Audio/AudioTriggerComponentBus.h>
 
+#include <AzCore/IO/Path/Path.h>
+
 #include <IAudioSystem.h>
+#include <ISystem.h>
 
 using namespace Audio;
 
@@ -68,11 +71,16 @@ namespace LmbrCentral
         {
             behaviorContext->EBus<AudioSystemComponentRequestBus>("AudioSystemComponentRequestBus")
                 ->Event("GlobalStopAllSounds", &AudioSystemComponentRequestBus::Events::GlobalStopAllSounds)
+                ->Event("GlobalMuteAudio", &AudioSystemComponentRequestBus::Events::GlobalMuteAudio)
+                ->Event("GlobalUnmuteAudio", &AudioSystemComponentRequestBus::Events::GlobalUnmuteAudio)
+                ->Event("GlobalRefreshAudio", &AudioSystemComponentRequestBus::Events::GlobalRefreshAudio)
                 ->Event("GlobalExecuteAudioTrigger", &AudioSystemComponentRequestBus::Events::GlobalExecuteAudioTrigger)
                 ->Event("GlobalKillAudioTrigger", &AudioSystemComponentRequestBus::Events::GlobalKillAudioTrigger)
                 ->Event("GlobalSetAudioRtpc", &AudioSystemComponentRequestBus::Events::GlobalSetAudioRtpc)
                 ->Event("GlobalResetAudioRtpcs", &AudioSystemComponentRequestBus::Events::GlobalResetAudioRtpcs)
                 ->Event("GlobalSetAudioSwitchState", &AudioSystemComponentRequestBus::Events::GlobalSetAudioSwitchState)
+                ->Event("LevelLoadAudio", &AudioSystemComponentRequestBus::Events::LevelLoadAudio)
+                ->Event("LevelUnloadAudio", &AudioSystemComponentRequestBus::Events::LevelUnloadAudio)
                 ;
 
             behaviorContext->EBus<AudioSystemComponentNotificationBus>("Audio System Component Notifications", "AudioSystemComponentNotificationBus")
@@ -114,6 +122,12 @@ namespace LmbrCentral
         CrySystemEventBus::Handler::BusDisconnect();
     }
 
+    ////////////////////////////////////////////////////////////////////////
+    bool AudioSystemComponent::IsAudioSystemInitialized()
+    {
+        return Audio::AudioSystemRequestBus::HasHandlers();
+    }
+
     ////////////////////////////////////////////////////////////////////////
     void AudioSystemComponent::GlobalStopAllSounds()
     {
@@ -124,6 +138,32 @@ namespace LmbrCentral
         AudioSystemRequestBus::Broadcast(&AudioSystemRequestBus::Events::PushRequest, request);
     }
 
+    ////////////////////////////////////////////////////////////////////////
+    void AudioSystemComponent::GlobalMuteAudio()
+    {
+        SAudioRequest request;
+        SAudioManagerRequestData<eAMRT_MUTE_ALL> requestData;
+        request.pData = &requestData;
+
+        AudioSystemRequestBus::Broadcast(&AudioSystemRequestBus::Events::PushRequest, request);
+    }
+
+    ////////////////////////////////////////////////////////////////////////
+    void AudioSystemComponent::GlobalUnmuteAudio()
+    {
+        SAudioRequest request;
+        SAudioManagerRequestData<eAMRT_UNMUTE_ALL> requestData;
+        request.pData = &requestData;
+
+        AudioSystemRequestBus::Broadcast(&AudioSystemRequestBus::Events::PushRequest, request);
+    }
+
+    ////////////////////////////////////////////////////////////////////////
+    void AudioSystemComponent::GlobalRefreshAudio(AZStd::string_view levelName)
+    {
+        AudioSystemRequestBus::Broadcast(&AudioSystemRequestBus::Events::RefreshAudioSystem, levelName.data());
+    }
+
     ////////////////////////////////////////////////////////////////////////
     void AudioSystemComponent::GlobalExecuteAudioTrigger(const char* triggerName, AZ::EntityId callbackOwnerEntityId)
     {
@@ -231,33 +271,105 @@ namespace LmbrCentral
     }
 
     ////////////////////////////////////////////////////////////////////////
-    void AudioSystemComponent::OnCrySystemInitialized(ISystem&, const SSystemInitParams&)
+    void AudioSystemComponent::LevelLoadAudio(AZStd::string_view levelName)
     {
-        Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::AddRequestListener,
-            &AudioSystemComponent::OnAudioEvent,
-            this,
-            Audio::eART_AUDIO_CALLBACK_MANAGER_REQUEST,
-            Audio::eACMRT_REPORT_FINISHED_TRIGGER_INSTANCE
-        );
+        const char* controlsPath = nullptr;
+        AudioSystemRequestBus::BroadcastResult(controlsPath, &AudioSystemRequestBus::Events::GetControlsPath);
+        if (!controlsPath)
+        {
+            return;
+        }
+
+        AZ::IO::FixedMaxPath levelControlsPath{ controlsPath };
+        levelControlsPath /= "levels";
+        levelControlsPath /= levelName;
+
+        SAudioRequest request;
+        SAudioManagerRequestData<eAMRT_PARSE_CONTROLS_DATA> requestData(levelControlsPath.Native().data(), eADS_LEVEL_SPECIFIC);
+        request.nFlags = (eARF_PRIORITY_HIGH | eARF_EXECUTE_BLOCKING);
+        request.pData = &requestData;
+        AudioSystemRequestBus::Broadcast(&AudioSystemRequestBus::Events::PushRequestBlocking, request);
+
+        SAudioManagerRequestData<eAMRT_PARSE_PRELOADS_DATA> requestData2(levelControlsPath.Native().data(), eADS_LEVEL_SPECIFIC);
+        request.pData = &requestData2;
+        AudioSystemRequestBus::Broadcast(&AudioSystemRequestBus::Events::PushRequestBlocking, request);
+
+        TAudioPreloadRequestID preloadRequestId = INVALID_AUDIO_PRELOAD_REQUEST_ID;
+        AudioSystemRequestBus::BroadcastResult(
+            preloadRequestId, &AudioSystemRequestBus::Events::GetAudioPreloadRequestID, levelName.data());
+        if (preloadRequestId != INVALID_AUDIO_PRELOAD_REQUEST_ID)
+        {
+            SAudioManagerRequestData<eAMRT_PRELOAD_SINGLE_REQUEST> requestData3(preloadRequestId);
+            request.pData = &requestData3;
+            AudioSystemRequestBus::Broadcast(&AudioSystemRequestBus::Events::PushRequestBlocking, request);
+        }
     }
 
     ////////////////////////////////////////////////////////////////////////
-    void AudioSystemComponent::OnCrySystemShutdown(ISystem&)
+    void AudioSystemComponent::LevelUnloadAudio()
     {
-        Audio::AudioSystemRequestBus::Broadcast(&Audio::AudioSystemRequestBus::Events::RemoveRequestListener,
+        SAudioRequest request;
+
+        // Unload level-specific banks...
+        SAudioManagerRequestData<eAMRT_UNLOAD_AFCM_DATA_BY_SCOPE> requestData(eADS_LEVEL_SPECIFIC);
+        request.nFlags = (eARF_PRIORITY_HIGH | eARF_EXECUTE_BLOCKING);
+        request.pData = &requestData;
+        AudioSystemRequestBus::Broadcast(&AudioSystemRequestBus::Events::PushRequestBlocking, request);
+
+        // Now unload level-specific audio config data (controls then preloads)...
+        SAudioManagerRequestData<eAMRT_CLEAR_CONTROLS_DATA> requestData2(eADS_LEVEL_SPECIFIC);
+        request.pData = &requestData2;
+        AudioSystemRequestBus::Broadcast(&AudioSystemRequestBus::Events::PushRequestBlocking, request);
+
+        SAudioManagerRequestData<eAMRT_CLEAR_PRELOADS_DATA> requestData3(eADS_LEVEL_SPECIFIC);
+        request.pData = &requestData3;
+        AudioSystemRequestBus::Broadcast(&AudioSystemRequestBus::Events::PushRequestBlocking, request);
+    }
+
+    ////////////////////////////////////////////////////////////////////////
+    void AudioSystemComponent::OnCrySystemInitialized(ISystem& system, const SSystemInitParams&)
+    {
+        AudioSystemRequestBus::Broadcast(&AudioSystemRequestBus::Events::AddRequestListener,
+            &AudioSystemComponent::OnAudioEvent,
+            this,
+            eART_AUDIO_CALLBACK_MANAGER_REQUEST,
+            eACMRT_REPORT_FINISHED_TRIGGER_INSTANCE
+        );
+
+        system.GetILevelSystem()->AddListener(this);
+    }
+
+    ////////////////////////////////////////////////////////////////////////
+    void AudioSystemComponent::OnCrySystemShutdown(ISystem& system)
+    {
+        AudioSystemRequestBus::Broadcast(&AudioSystemRequestBus::Events::RemoveRequestListener,
             &AudioSystemComponent::OnAudioEvent,
             this
         );
+
+        system.GetILevelSystem()->RemoveListener(this);
+    }
+
+    ////////////////////////////////////////////////////////////////////////
+    void AudioSystemComponent::OnLoadingStart(const char* levelName)
+    {
+        LevelLoadAudio(AZStd::string_view{ levelName });
+    }
+
+    ////////////////////////////////////////////////////////////////////////
+    void AudioSystemComponent::OnUnloadComplete([[maybe_unused]] const char* levelName)
+    {
+        LevelUnloadAudio();
     }
 
     ////////////////////////////////////////////////////////////////////////
     // static
-    void AudioSystemComponent::OnAudioEvent(const Audio::SAudioRequestInfo* const requestInfo)
+    void AudioSystemComponent::OnAudioEvent(const SAudioRequestInfo* const requestInfo)
     {
-        if (requestInfo->eAudioRequestType == Audio::eART_AUDIO_CALLBACK_MANAGER_REQUEST)
+        if (requestInfo->eAudioRequestType == eART_AUDIO_CALLBACK_MANAGER_REQUEST)
         {
-            const auto notificationType = static_cast<Audio::EAudioCallbackManagerRequestType>(requestInfo->nSpecificAudioRequest);
-            if (notificationType == Audio::eACMRT_REPORT_FINISHED_TRIGGER_INSTANCE && requestInfo->eResult == Audio::eARR_SUCCESS)
+            const auto notificationType = static_cast<EAudioCallbackManagerRequestType>(requestInfo->nSpecificAudioRequest);
+            if (notificationType == eACMRT_REPORT_FINISHED_TRIGGER_INSTANCE && requestInfo->eResult == eARR_SUCCESS)
             {
                 AZ::EntityId callbackOwnerEntityId(reinterpret_cast<AZ::u64>(requestInfo->pUserData));
                 AudioTriggerComponentNotificationBus::Event(callbackOwnerEntityId, &AudioTriggerComponentNotificationBus::Events::OnTriggerFinished, requestInfo->nAudioControlID);
diff --git a/Gems/LmbrCentral/Code/Source/Audio/AudioSystemComponent.h b/Gems/LmbrCentral/Code/Source/Audio/AudioSystemComponent.h
index 6a8935ae43..5f25f87198 100644
--- a/Gems/LmbrCentral/Code/Source/Audio/AudioSystemComponent.h
+++ b/Gems/LmbrCentral/Code/Source/Audio/AudioSystemComponent.h
@@ -14,6 +14,7 @@
 
 #include <CrySystemBus.h>
 #include <IAudioInterfacesCommonData.h>
+#include <ILevelSystem.h>
 
 namespace LmbrCentral
 {
@@ -26,6 +27,7 @@ namespace LmbrCentral
         : public AZ::Component
         , protected AudioSystemComponentRequestBus::Handler
         , public CrySystemEventBus::Handler
+        , public ILevelSystemListener
     {
     public:
         AZ_COMPONENT(AudioSystemComponent, "{666E28D2-FC99-4D41-861D-3758C5070653}");
@@ -49,18 +51,29 @@ namespace LmbrCentral
 
         ////////////////////////////////////////////////////////////////////////
         // AudioSystemComponentRequestBus::Handler interface implementation
+        bool IsAudioSystemInitialized() override;
         void GlobalStopAllSounds() override;
+        void GlobalMuteAudio() override;
+        void GlobalUnmuteAudio() override;
+        void GlobalRefreshAudio(AZStd::string_view levelName) override;
         void GlobalExecuteAudioTrigger(const char* triggerName, AZ::EntityId callbackOwnerEntityId) override;
         void GlobalKillAudioTrigger(const char* triggerName, AZ::EntityId callbackOwnerEntityId) override;
         void GlobalSetAudioRtpc(const char* rtpcName, float value) override;
         void GlobalResetAudioRtpcs() override;
         void GlobalSetAudioSwitchState(const char* switchName, const char* stateName) override;
+        void LevelLoadAudio(AZStd::string_view levelName) override;
+        void LevelUnloadAudio() override;
 
         ////////////////////////////////////////////////////////////////////////
         // CrySystemEventBus::Handler interface implementation
         void OnCrySystemInitialized(ISystem&, const SSystemInitParams&) override;
         void OnCrySystemShutdown(ISystem&) override;
 
+        ////////////////////////////////////////////////////////////////////////
+        // ILevelSystemListener interface implementation
+        void OnLoadingStart(const char* levelName) override;
+        void OnUnloadComplete(const char* levelName) override;
+
     private:
         static void OnAudioEvent(const Audio::SAudioRequestInfo* const);
     };
diff --git a/Gems/LmbrCentral/Code/include/LmbrCentral/Audio/AudioSystemComponentBus.h b/Gems/LmbrCentral/Code/include/LmbrCentral/Audio/AudioSystemComponentBus.h
index 56c1cbf6c1..d8ba1e014f 100644
--- a/Gems/LmbrCentral/Code/include/LmbrCentral/Audio/AudioSystemComponentBus.h
+++ b/Gems/LmbrCentral/Code/include/LmbrCentral/Audio/AudioSystemComponentBus.h
@@ -28,12 +28,23 @@ namespace LmbrCentral
         static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
         static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
 
+        virtual bool IsAudioSystemInitialized()
+        {
+            return false;
+        }
+
         virtual void GlobalStopAllSounds() = 0;
+        virtual void GlobalMuteAudio() = 0;
+        virtual void GlobalUnmuteAudio() = 0;
+        virtual void GlobalRefreshAudio(AZStd::string_view levelName) = 0;
         virtual void GlobalExecuteAudioTrigger(const char* triggerName, AZ::EntityId callbackOwnerEntityId) = 0;
         virtual void GlobalKillAudioTrigger(const char* triggerName, AZ::EntityId callbackOwnerEntityId) = 0;
         virtual void GlobalSetAudioRtpc(const char* rtpcName, float value) = 0;
         virtual void GlobalResetAudioRtpcs() = 0;
         virtual void GlobalSetAudioSwitchState(const char* switchName, const char* stateName) = 0;
+
+        virtual void LevelLoadAudio(AZStd::string_view levelName) = 0;
+        virtual void LevelUnloadAudio() = 0;
     };
 
     using AudioSystemComponentRequestBus = AZ::EBus<AudioSystemComponentRequests>;
diff --git a/Gems/LyShine/Code/Source/Animation/AzEntityNode.cpp b/Gems/LyShine/Code/Source/Animation/AzEntityNode.cpp
index a98b651ea0..814d1404b4 100644
--- a/Gems/LyShine/Code/Source/Animation/AzEntityNode.cpp
+++ b/Gems/LyShine/Code/Source/Animation/AzEntityNode.cpp
@@ -16,7 +16,6 @@
 #include "PNoise3.h"
 #include "AnimSequence.h"
 
-#include <IAudioSystem.h>
 #include <Cry_Camera.h>
 
 #include <AzCore/Serialization/SerializeContext.h>

From db91bdbf51318e82d753a349cc1097c1d7da92b2 Mon Sep 17 00:00:00 2001
From: Mikhail Naumov <mnaumov@amazon.com>
Date: Tue, 17 Aug 2021 18:25:22 -0700
Subject: [PATCH 15/37] Improvements to Entity Outliner context menu

Signed-off-by: Mikhail Naumov <mnaumov@amazon.com>
---
 .../SandboxIntegration.cpp                    | 29 +++++++++++++------
 .../UI/Prefab/PrefabIntegrationManager.cpp    | 22 +++++++++++---
 2 files changed, 38 insertions(+), 13 deletions(-)

diff --git a/Code/Editor/Plugins/ComponentEntityEditorPlugin/SandboxIntegration.cpp b/Code/Editor/Plugins/ComponentEntityEditorPlugin/SandboxIntegration.cpp
index b10fe35513..6b60f96089 100644
--- a/Code/Editor/Plugins/ComponentEntityEditorPlugin/SandboxIntegration.cpp
+++ b/Code/Editor/Plugins/ComponentEntityEditorPlugin/SandboxIntegration.cpp
@@ -646,16 +646,27 @@ void SandboxIntegrationManager::PopulateEditorGlobalContextMenu(QMenu* menu, con
 
     QAction* action = nullptr;
 
-    action = menu->addAction(QObject::tr("Create entity"));
-    QObject::connect(action, &QAction::triggered, action, [this] { ContextMenu_NewEntity(); });
-
-    if (selected.size() == 1)
+    // when nothing is selected, entity is created at root level
+    if (selected.size() == 0)
     {
-        action = menu->addAction(QObject::tr("Create child entity"));
-        QObject::connect(action, &QAction::triggered, action, [selected]
-        {
-            EBUS_EVENT(AzToolsFramework::EditorRequests::Bus, CreateNewEntityAsChild, selected.front());
-        });
+        action = menu->addAction(QObject::tr("Create entity"));
+        QObject::connect(
+            action, &QAction::triggered, action,
+            [this]
+            {
+                ContextMenu_NewEntity();
+            });
+    }
+    // when a single entity is selected, entity is created as its child
+    else if (selected.size() == 1)
+    {
+        action = menu->addAction(QObject::tr("Create entity"));
+        QObject::connect(
+            action, &QAction::triggered, action,
+            [selected]
+            {
+                EBUS_EVENT(AzToolsFramework::EditorRequests::Bus, CreateNewEntityAsChild, selected.front());
+            });
     }
 
     bool prefabSystemEnabled = false;
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/Prefab/PrefabIntegrationManager.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/Prefab/PrefabIntegrationManager.cpp
index eb9cf2b65f..7f3fbbeb38 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/Prefab/PrefabIntegrationManager.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/Prefab/PrefabIntegrationManager.cpp
@@ -11,6 +11,7 @@
 #include <AzCore/IO/FileIO.h>
 #include <AzCore/IO/SystemFile.h>
 #include <AzCore/StringFunc/StringFunc.h>
+#include <AzCore/Component/TransformBus.h>
 
 #include <AzFramework/API/ApplicationAPI.h>
 #include <AzFramework/Asset/AssetSystemBus.h>
@@ -363,12 +364,25 @@ namespace AzToolsFramework
 
             if (hasUserSelectedValidSourceFile)
             {
-                // Get position (center of viewport). If no viewport is available, (0,0,0) will be used.
-                AZ::Vector3 viewportCenterPosition = AZ::Vector3::CreateZero();
-                EditorRequestBus::BroadcastResult(viewportCenterPosition, &EditorRequestBus::Events::GetWorldPositionAtViewportCenter);
+                AZ::EntityId parentId;
+                AZ::Vector3 position = AZ::Vector3::CreateZero();
+
+                // if one entity is selected, set it as parent
+                EntityIdList selectedEntities;
+                ToolsApplicationRequestBus::BroadcastResult(selectedEntities, &ToolsApplicationRequests::GetSelectedEntities);
+                if (selectedEntities.size() == 1)
+                {
+                    parentId = selectedEntities.front();
+                    AZ::TransformBus::EventResult(position, parentId, &AZ::TransformInterface::GetWorldTranslation);
+                }
+                else
+                {
+                    // Get position (center of viewport). If no viewport is available, (0,0,0) will be used.
+                    EditorRequestBus::BroadcastResult(position, &EditorRequestBus::Events::GetWorldPositionAtViewportCenter);
+                }
 
                 // Instantiating from context menu always puts the instance at the root level
-                auto createPrefabOutcome = s_prefabPublicInterface->InstantiatePrefab(prefabFilePath, AZ::EntityId(), viewportCenterPosition);
+                auto createPrefabOutcome = s_prefabPublicInterface->InstantiatePrefab(prefabFilePath, parentId, position);
 
                 if (!createPrefabOutcome.IsSuccess())
                 {

From 697fbcf121c8687be9f9c846850780519360c647 Mon Sep 17 00:00:00 2001
From: hultonha <hultonha@amazon.co.uk>
Date: Wed, 18 Aug 2021 10:54:34 +0100
Subject: [PATCH 16/37] move static variable initialization out of class
 definition

Signed-off-by: hultonha <hultonha@amazon.co.uk>
---
 Code/Editor/Lib/Tests/test_ViewportManipulatorController.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Code/Editor/Lib/Tests/test_ViewportManipulatorController.cpp b/Code/Editor/Lib/Tests/test_ViewportManipulatorController.cpp
index a2a7617083..9dc7e65cef 100644
--- a/Code/Editor/Lib/Tests/test_ViewportManipulatorController.cpp
+++ b/Code/Editor/Lib/Tests/test_ViewportManipulatorController.cpp
@@ -77,7 +77,7 @@ namespace UnitTest
     class ViewportManipulatorControllerFixture : public AllocatorsTestFixture
     {
     public:
-        static const AzFramework::ViewportId TestViewportId = AzFramework::ViewportId(0);
+        static const AzFramework::ViewportId TestViewportId;
 
         void SetUp() override
         {
@@ -108,6 +108,8 @@ namespace UnitTest
         AZStd::unique_ptr<AzToolsFramework::QtEventToAzInputMapper> m_inputChannelMapper;
     };
 
+    const AzFramework::ViewportId ViewportManipulatorControllerFixture::TestViewportId = AzFramework::ViewportId(0);
+
     TEST_F(ViewportManipulatorControllerFixture, An_event_is_not_propagated_to_the_viewport_when_a_manipulator_handles_it_first)
     {
         // forward input events to our controller list

From 740ee1f8a402b88e2af28ac759a92996f1783250 Mon Sep 17 00:00:00 2001
From: John Jones-Steele <jjjoness@amazon.com>
Date: Wed, 18 Aug 2021 12:27:10 +0100
Subject: [PATCH 17/37] Fixed wheel working on spinbox non focussed

Signed-off-by: John Jones-Steele <jjjoness@amazon.com>
---
 .../AzQtComponents/Components/Widgets/SpinBox.cpp               | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Code/Framework/AzQtComponents/AzQtComponents/Components/Widgets/SpinBox.cpp b/Code/Framework/AzQtComponents/AzQtComponents/Components/Widgets/SpinBox.cpp
index fc73f88d1c..06361ceee9 100644
--- a/Code/Framework/AzQtComponents/AzQtComponents/Components/Widgets/SpinBox.cpp
+++ b/Code/Framework/AzQtComponents/AzQtComponents/Components/Widgets/SpinBox.cpp
@@ -366,7 +366,7 @@ bool SpinBoxWatcher::filterSpinBoxEvents(QAbstractSpinBox* spinBox, QEvent* even
             {
                 // To prevent the event being turned into a focus event, be sure to install an
                 // AzQtComponents::GlobalEventFilter on your QApplication instance.
-                event->ignore();
+                event->accept();
                 return true;
             }
 

From 7164b64bb5810183d9bfd1b6cc0ac8f49c52184b Mon Sep 17 00:00:00 2001
From: amzn-victor <86271008+amzn-victor@users.noreply.github.com>
Date: Wed, 18 Aug 2021 09:48:24 -0700
Subject: [PATCH 18/37] Move BuildDebugSceneGraph function out of
 SceneProcessing gem (#3290)

Moved BuildDebugSceneGraph out of SceneProcessing gem and into DebugOutput class to allow the function to be shared, which ensures the same dbgsg format is outputted among any calls to the function.

* Move BuildDebugSceneGraph function, update all calls to this function

Signed-off-by: Victor Huang <huavicto@amazon.com>

* Remove unused includes

Signed-off-by: Victor Huang <huavicto@amazon.com>

* Remove z

Signed-off-by: Victor Huang <huavicto@amazon.com>
---
 .../SceneCore/Utilities/DebugOutput.cpp       | 68 ++++++++++++++++++
 .../SceneCore/Utilities/DebugOutput.h         | 18 +++++
 .../SceneBuilder/SceneBuilderWorker.cpp       | 69 ++-----------------
 .../Source/SceneBuilder/SceneBuilderWorker.h  |  3 -
 4 files changed, 90 insertions(+), 68 deletions(-)

diff --git a/Code/Tools/SceneAPI/SceneCore/Utilities/DebugOutput.cpp b/Code/Tools/SceneAPI/SceneCore/Utilities/DebugOutput.cpp
index e688ebccd4..de727498fc 100644
--- a/Code/Tools/SceneAPI/SceneCore/Utilities/DebugOutput.cpp
+++ b/Code/Tools/SceneAPI/SceneCore/Utilities/DebugOutput.cpp
@@ -9,6 +9,15 @@
 #include "DebugOutput.h"
 #include <AzCore/std/optional.h>
 
+#include <AzCore/IO/SystemFile.h>
+#include <AzFramework/StringFunc/StringFunc.h>
+#include <SceneAPI/SceneCore/Containers/Scene.h>
+#include <SceneAPI/SceneCore/Containers/Views/PairIterator.h>
+#include <SceneAPI/SceneCore/Containers/Views/SceneGraphDownwardsIterator.h>
+#include <SceneAPI/SceneCore/DataTypes/IGraphObject.h>
+#include <SceneAPI/SceneCore/Events/ExportProductList.h>
+#include <SceneAPI/SceneCore/Utilities/Reporting.h>
+
 namespace AZ::SceneAPI::Utilities
 {
     void DebugOutput::Write(const char* name, const char* data)
@@ -118,4 +127,63 @@ namespace AZ::SceneAPI::Utilities
     {
         return m_output;
     }
+
+    void WriteAndLog(AZ::IO::SystemFile& dbgFile, const char* strToWrite)
+    {
+        AZ_TracePrintf(AZ::SceneAPI::Utilities::LogWindow, "%s", strToWrite);
+        dbgFile.Write(strToWrite, strlen(strToWrite));
+        dbgFile.Write("\n", strlen("\n"));
+    }
+
+    void DebugOutput::BuildDebugSceneGraph(const char* outputFolder, AZ::SceneAPI::Events::ExportProductList& productList, const AZStd::shared_ptr<AZ::SceneAPI::Containers::Scene>& scene, AZStd::string productName)
+    {
+        const int debugSceneGraphVersion = 1;
+        AZStd::string debugSceneFile;
+
+        AzFramework::StringFunc::Path::ConstructFull(outputFolder, productName.c_str(), debugSceneFile);
+        AZ_TracePrintf(AZ::SceneAPI::Utilities::LogWindow, "outputFolder %s, name %s.\n", outputFolder, productName.c_str());
+        
+        AZ::IO::SystemFile dbgFile;
+        if (dbgFile.Open(debugSceneFile.c_str(), AZ::IO::SystemFile::SF_OPEN_CREATE | AZ::IO::SystemFile::SF_OPEN_WRITE_ONLY))
+        {
+            WriteAndLog(dbgFile, AZStd::string::format("ProductName: %s", productName.c_str()).c_str());
+            WriteAndLog(dbgFile, AZStd::string::format("debugSceneGraphVersion: %d", debugSceneGraphVersion).c_str());
+            WriteAndLog(dbgFile, scene->GetName().c_str());
+
+            const AZ::SceneAPI::Containers::SceneGraph& sceneGraph = scene->GetGraph();
+            auto names = sceneGraph.GetNameStorage();
+            auto content = sceneGraph.GetContentStorage();
+            auto pairView = AZ::SceneAPI::Containers::Views::MakePairView(names, content);
+            auto view = AZ::SceneAPI::Containers::Views::MakeSceneGraphDownwardsView<
+                AZ::SceneAPI::Containers::Views::BreadthFirst>(
+                    sceneGraph, sceneGraph.GetRoot(), pairView.cbegin(), true);
+
+            for (auto&& viewIt : view)
+            {
+                if (viewIt.second == nullptr)
+                {
+                    continue;
+                }
+
+                AZ::SceneAPI::DataTypes::IGraphObject* graphObject = const_cast<AZ::SceneAPI::DataTypes::IGraphObject*>(viewIt.second.get());
+                
+                WriteAndLog(dbgFile, AZStd::string::format("Node Name: %s", viewIt.first.GetName()).c_str());
+                WriteAndLog(dbgFile, AZStd::string::format("Node Path: %s", viewIt.first.GetPath()).c_str());
+                WriteAndLog(dbgFile, AZStd::string::format("Node Type: %s", graphObject->RTTI_GetTypeName()).c_str());
+
+                AZ::SceneAPI::Utilities::DebugOutput debugOutput;
+                viewIt.second->GetDebugOutput(debugOutput);
+
+                if (!debugOutput.GetOutput().empty())
+                {
+                    WriteAndLog(dbgFile, debugOutput.GetOutput().c_str());
+                }
+            }
+            dbgFile.Close();
+
+            static const AZ::Data::AssetType dbgSceneGraphAssetType("{07F289D1-4DC7-4C40-94B4-0A53BBCB9F0B}");
+            productList.AddProduct(productName, AZ::Uuid::CreateName(productName.c_str()), dbgSceneGraphAssetType,
+                AZStd::nullopt, AZStd::nullopt);
+        }
+    }
 }
diff --git a/Code/Tools/SceneAPI/SceneCore/Utilities/DebugOutput.h b/Code/Tools/SceneAPI/SceneCore/Utilities/DebugOutput.h
index 5fe5b98243..e05d10e2fa 100644
--- a/Code/Tools/SceneAPI/SceneCore/Utilities/DebugOutput.h
+++ b/Code/Tools/SceneAPI/SceneCore/Utilities/DebugOutput.h
@@ -16,6 +16,22 @@
 #include <AzCore/std/optional.h>
 #include <cinttypes>
 
+namespace AZ
+{
+    namespace SceneAPI
+    {
+        namespace Containers
+        {
+            class Scene;
+        }
+        namespace Events
+        {
+            struct ExportProduct;
+            class ExportProductList;
+        }
+    }
+}
+
 namespace AZ::SceneAPI::Utilities
 {
     class DebugOutput
@@ -42,6 +58,8 @@ namespace AZ::SceneAPI::Utilities
 
         SCENE_CORE_API const AZStd::string& GetOutput() const;
 
+        SCENE_CORE_API static void BuildDebugSceneGraph(const char* outputFolder, AZ::SceneAPI::Events::ExportProductList& productList, const AZStd::shared_ptr<AZ::SceneAPI::Containers::Scene>& scene, AZStd::string productName);
+
     protected:
         AZStd::string m_output;
     };
diff --git a/Gems/SceneProcessing/Code/Source/SceneBuilder/SceneBuilderWorker.cpp b/Gems/SceneProcessing/Code/Source/SceneBuilder/SceneBuilderWorker.cpp
index 18ee0285b8..b4ae490e2c 100644
--- a/Gems/SceneProcessing/Code/Source/SceneBuilder/SceneBuilderWorker.cpp
+++ b/Gems/SceneProcessing/Code/Source/SceneBuilder/SceneBuilderWorker.cpp
@@ -10,9 +10,7 @@
 #include <AzCore/IO/FileIO.h>
 #include <AzCore/IO/SystemFile.h>
 #include <AzCore/Serialization/Utils.h>
-#include <SceneAPI/SceneCore/Containers/Views/PairIterator.h>
 #include <SceneAPI/SceneCore/DataTypes/IGraphObject.h>
-#include <SceneAPI/SceneCore/Containers/Views/SceneGraphDownwardsIterator.h>
 #include <AzCore/Serialization/SerializeContext.h>
 #include <AzCore/std/containers/set.h>
 #include <AzFramework/Application/Application.h>
@@ -306,7 +304,10 @@ namespace SceneBuilder
 
         if (itr != request.m_jobDescription.m_jobParameters.end() && itr->second == "true")
         {
-            BuildDebugSceneGraph(outputFolder.c_str(), productList, scene);
+            AZStd::string productName;
+            AzFramework::StringFunc::Path::GetFullFileName(scene->GetSourceFilename().c_str(), productName);
+            AzFramework::StringFunc::Path::ReplaceExtension(productName, "dbgsg");
+            AZ::SceneAPI::Utilities::DebugOutput::BuildDebugSceneGraph(outputFolder.c_str(), productList, scene, productName);
         }
 
         AZ_TracePrintf(Utilities::LogWindow, "Collecting and registering products.\n");
@@ -371,66 +372,4 @@ namespace SceneBuilder
 
         return id;
     }
-
-    void WriteAndLog(AZ::IO::SystemFile& dbgFile, const char* strToWrite)
-    {
-        AZ_TracePrintf(AZ::SceneAPI::Utilities::LogWindow, "%s", strToWrite);
-        dbgFile.Write(strToWrite, strlen(strToWrite));
-        dbgFile.Write("\n", strlen("\n"));
-
-    }
-
-    void SceneBuilderWorker::BuildDebugSceneGraph(const char* outputFolder, AZ::SceneAPI::Events::ExportProductList& productList, const AZStd::shared_ptr<AZ::SceneAPI::Containers::Scene>& scene) const
-    {
-        const int debugSceneGraphVersion = 1;
-        AZStd::string productName, debugSceneFile;
-
-        AzFramework::StringFunc::Path::GetFullFileName(scene->GetSourceFilename().c_str(), productName);
-        AzFramework::StringFunc::Path::ReplaceExtension(productName, "dbgsg");
-        AzFramework::StringFunc::Path::ConstructFull(outputFolder, productName.c_str(), debugSceneFile);
-        AZ_TracePrintf(AZ::SceneAPI::Utilities::LogWindow, "outputFolder %s, name %s.\n", outputFolder, productName.c_str());
-        
-        AZ::IO::SystemFile dbgFile;
-        if (dbgFile.Open(debugSceneFile.c_str(), AZ::IO::SystemFile::SF_OPEN_CREATE | AZ::IO::SystemFile::SF_OPEN_WRITE_ONLY))
-        {
-            WriteAndLog(dbgFile, AZStd::string::format("ProductName: %s", productName.c_str()).c_str());
-            WriteAndLog(dbgFile, AZStd::string::format("debugSceneGraphVersion: %d", debugSceneGraphVersion).c_str());
-            WriteAndLog(dbgFile, scene->GetName().c_str());
-
-            const AZ::SceneAPI::Containers::SceneGraph& sceneGraph = scene->GetGraph();
-            auto names = sceneGraph.GetNameStorage();
-            auto content = sceneGraph.GetContentStorage();
-            auto pairView = AZ::SceneAPI::Containers::Views::MakePairView(names, content);
-            auto view = AZ::SceneAPI::Containers::Views::MakeSceneGraphDownwardsView<
-                AZ::SceneAPI::Containers::Views::BreadthFirst>(
-                    sceneGraph, sceneGraph.GetRoot(), pairView.cbegin(), true);
-
-            for (auto&& viewIt : view)
-            {
-                if (viewIt.second == nullptr)
-                {
-                    continue;
-                }
-
-                AZ::SceneAPI::DataTypes::IGraphObject* graphObject = const_cast<AZ::SceneAPI::DataTypes::IGraphObject*>(viewIt.second.get());
-                
-                WriteAndLog(dbgFile, AZStd::string::format("Node Name: %s", viewIt.first.GetName()).c_str());
-                WriteAndLog(dbgFile, AZStd::string::format("Node Path: %s", viewIt.first.GetPath()).c_str());
-                WriteAndLog(dbgFile, AZStd::string::format("Node Type: %s", graphObject->RTTI_GetTypeName()).c_str());
-
-                AZ::SceneAPI::Utilities::DebugOutput debugOutput;
-                viewIt.second->GetDebugOutput(debugOutput);
-
-                if (!debugOutput.GetOutput().empty())
-                {
-                    WriteAndLog(dbgFile, debugOutput.GetOutput().c_str());
-                }
-            }
-            dbgFile.Close();
-
-            static const AZ::Data::AssetType dbgSceneGraphAssetType("{07F289D1-4DC7-4C40-94B4-0A53BBCB9F0B}");
-            productList.AddProduct(productName, AZ::Uuid::CreateName(productName.c_str()), dbgSceneGraphAssetType,
-                AZStd::nullopt, AZStd::nullopt);
-        }
-    }
 } // namespace SceneBuilder
diff --git a/Gems/SceneProcessing/Code/Source/SceneBuilder/SceneBuilderWorker.h b/Gems/SceneProcessing/Code/Source/SceneBuilder/SceneBuilderWorker.h
index 895bcf5672..3ecc657a3a 100644
--- a/Gems/SceneProcessing/Code/Source/SceneBuilder/SceneBuilderWorker.h
+++ b/Gems/SceneProcessing/Code/Source/SceneBuilder/SceneBuilderWorker.h
@@ -55,9 +55,6 @@ namespace SceneBuilder
         void PopulateProductDependencies(const AZ::SceneAPI::Events::ExportProduct& exportProduct, const char* watchFolder, AssetBuilderSDK::JobProduct& jobProduct) const;
 
     protected:
-
-        void BuildDebugSceneGraph(const char* outputFolder, AZ::SceneAPI::Events::ExportProductList& productList, const AZStd::shared_ptr<AZ::SceneAPI::Containers::Scene>& scene) const;
-
         bool LoadScene(AZStd::shared_ptr<AZ::SceneAPI::Containers::Scene>& result, 
             const AssetBuilderSDK::ProcessJobRequest& request, AssetBuilderSDK::ProcessJobResponse& response);
 

From e48798fdbf1527459fc16e1fc476488bfe85ae83 Mon Sep 17 00:00:00 2001
From: Shirang Jia <shiranj@amazon.com>
Date: Wed, 18 Aug 2021 10:02:24 -0700
Subject: [PATCH 19/37] Add missing {} for string interpolation (#3291)

---
 scripts/build/Jenkins/Jenkinsfile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/build/Jenkins/Jenkinsfile b/scripts/build/Jenkins/Jenkinsfile
index 1c0409ceec..e45b7075f0 100644
--- a/scripts/build/Jenkins/Jenkinsfile
+++ b/scripts/build/Jenkins/Jenkinsfile
@@ -643,7 +643,7 @@ try {
                             defaultValue = jenkinsParameter['default_value']
                             // Use last run's value as default value so we can save values in different Jenkins environment
                             if (jenkinsParameter['use_last_run_value']?.toBoolean()) {
-                                defaultValue = params."$jenkinsParameter['parameter_name']" ?: jenkinsParameter['default_value']
+                                defaultValue = params."${jenkinsParameter['parameter_name']}" ?: jenkinsParameter['default_value']
                             }
                             switch (jenkinsParameter['parameter_type']) {
                                 case 'string':

From 28d035c2756e865b201d706f8a283a85b3b60761 Mon Sep 17 00:00:00 2001
From: chiyenteng <82238204+chiyenteng@users.noreply.github.com>
Date: Wed, 18 Aug 2021 10:55:45 -0700
Subject: [PATCH 20/37] Add a new auto test for delete prefab workflow (#3143)

* Add a new auto test for delete prefab

Signed-off-by: chiyteng <chiyteng@amazon.com>
---
 .../prefab/PrefabLevel_BasicWorkflow.py       | 74 +++++++++++++++----
 .../Prefab/PrefabPublicHandler.cpp            |  4 +-
 .../Prefab/PrefabPublicHandler.h              |  4 +-
 .../Prefab/PrefabPublicInterface.h            |  4 +-
 .../Prefab/PrefabPublicRequestBus.h           | 24 +++++-
 .../Prefab/PrefabPublicRequestHandler.cpp     | 37 +++-------
 .../Prefab/PrefabPublicRequestHandler.h       |  5 +-
 7 files changed, 99 insertions(+), 53 deletions(-)

diff --git a/AutomatedTesting/Gem/PythonTests/prefab/PrefabLevel_BasicWorkflow.py b/AutomatedTesting/Gem/PythonTests/prefab/PrefabLevel_BasicWorkflow.py
index 44b7dc2ee4..7a600f7976 100644
--- a/AutomatedTesting/Gem/PythonTests/prefab/PrefabLevel_BasicWorkflow.py
+++ b/AutomatedTesting/Gem/PythonTests/prefab/PrefabLevel_BasicWorkflow.py
@@ -7,10 +7,14 @@ SPDX-License-Identifier: Apache-2.0 OR MIT
 
 # fmt:off
 class Tests():
-    create_new_entity =       ("Entity: 'CreateNewEntity' passed",                          "Entity: 'CreateNewEntity' failed")
-    create_prefab =           ("Prefab: 'CreatePrefab' passed",                             "Prefab: 'CreatePrefab' failed")
-    instantiate_prefab =      ("Prefab: 'InstantiatePrefab' passed",                        "Prefab: 'InstantiatePrefab' failed")
-    new_prefab_position =     ("Prefab: new prefab's position is at the expected position", "Prefab: new prefab's position is *not* at the expected position")
+    create_new_entity =            ("'CreateNewEntity' passed",                                   "'CreateNewEntity' failed")
+    create_prefab =                ("'CreatePrefab' passed",                                      "'CreatePrefab' failed")
+    instantiate_prefab =           ("'InstantiatePrefab' passed",                                 "'InstantiatePrefab' failed")
+    has_one_child =                ("instantiated prefab contains only one child as expected",    "instantiated prefab does *not* contain only one child as expected")
+    instantiated_prefab_position = ("instantiated prefab's position is at the expected position", "instantiated prefab's position is *not* at the expected position")
+    delete_prefab =                ("'DeleteEntitiesAndAllDescendantsInInstance' passed",         "'DeleteEntitiesAndAllDescendantsInInstance' failed")
+    instantiated_prefab_removed =  ("instantiated prefab's container entity has been removed",    "instantiated prefab's container entity has *not* been removed")
+    instantiated_child_removed =   ("instantiated prefab's child entity has been removed",        "instantiated prefab's child entity has *not* been removed")
 # fmt:on
 
 def PrefabLevel_BasicWorkflow():
@@ -18,6 +22,7 @@ def PrefabLevel_BasicWorkflow():
     This test will help verify if the following functions related to Prefab work as expected: 
     - CreatePrefab
     - InstantiatePrefab
+    - DeleteEntitiesAndAllDescendantsInInstance
     """
 
     import os
@@ -35,31 +40,68 @@ def PrefabLevel_BasicWorkflow():
     from azlmbr.math import Vector3
     import azlmbr.legacy.general as general
 
-    EXPECTED_NEW_PREFAB_POSITION = Vector3(10.00, 20.0, 30.0)
+    NEW_PREFAB_NAME = "new_prefab"
+    NEW_PREFAB_FILE_NAME = NEW_PREFAB_NAME + ".prefab"
+    NEW_PREFAB_FILE_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), NEW_PREFAB_FILE_NAME)
+    INSTANTIATED_PREFAB_POSITION = Vector3(10.00, 20.0, 30.0)
+    INSTANTIATED_PREFAB_NAME = "instantiated_prefab"
+    INSTANTIATED_CHILD_ENTITY_NAME = "child_1"
+    TEST_LEVEL_FOLDER = "Prefab"
+    TEST_LEVEL_NAME = "Base"
 
+    def find_entity_by_name(entity_name):
+        searchFilter = entity.SearchFilter()
+        searchFilter.names = [entity_name]
+        entityIds = entity.SearchBus(bus.Broadcast, 'SearchEntities', searchFilter)
+        if entityIds and entityIds[0].IsValid():
+            return entityIds[0]
+        return None
+
+    def print_error_if_failed(prefab_operation_result):
+        if not prefab_operation_result.IsSuccess():
+            Report.info(f'Error message: {prefab_operation_result.GetError()}')
+
+
+# Open the test level
     helper.init_idle()
-    helper.open_level("Prefab", "Base")
+    helper.open_level(TEST_LEVEL_FOLDER, TEST_LEVEL_NAME)
 
 # Create a new Entity at the root level
     new_entity_id = editor.ToolsApplicationRequestBus(bus.Broadcast, 'CreateNewEntity', EntityId())
     Report.result(Tests.create_new_entity, new_entity_id.IsValid())
 
 # Checks for prefab creation passed or not 
-    new_prefab_file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'new_prefab.prefab')
-    create_prefab_result = prefab.PrefabPublicRequestBus(bus.Broadcast, 'CreatePrefabInMemory', [new_entity_id], new_prefab_file_path)
-    Report.result(Tests.create_prefab, create_prefab_result)
+    create_prefab_result = prefab.PrefabPublicRequestBus(bus.Broadcast, 'CreatePrefabInMemory', [new_entity_id], NEW_PREFAB_FILE_PATH)
+    Report.result(Tests.create_prefab, create_prefab_result.IsSuccess())
+    print_error_if_failed(create_prefab_result)
 
 # Checks for prefab instantiation passed or not 
-    container_entity_id = prefab.PrefabPublicRequestBus(bus.Broadcast, 'InstantiatePrefab', new_prefab_file_path, EntityId(), EXPECTED_NEW_PREFAB_POSITION)
-    Report.result(Tests.instantiate_prefab, container_entity_id.IsValid())
+    instantiate_prefab_result = prefab.PrefabPublicRequestBus(bus.Broadcast, 'InstantiatePrefab', NEW_PREFAB_FILE_PATH, EntityId(), INSTANTIATED_PREFAB_POSITION)
+    Report.result(Tests.instantiate_prefab, instantiate_prefab_result.IsSuccess() and instantiate_prefab_result.GetValue().IsValid())
+    print_error_if_failed(instantiate_prefab_result)
+
+    container_entity_id = instantiate_prefab_result.GetValue()
+    editor.EditorEntityAPIBus(bus.Event, 'SetName', container_entity_id, INSTANTIATED_PREFAB_NAME)
+    
+    children_entity_ids = editor.EditorEntityInfoRequestBus(bus.Event, 'GetChildren', container_entity_id)
+    Report.result(Tests.has_one_child, len(children_entity_ids) is 1)
+
+    child_entity_id = children_entity_ids[0]
+    editor.EditorEntityAPIBus(bus.Event, 'SetName', child_entity_id, INSTANTIATED_CHILD_ENTITY_NAME)
 
 # Checks if the new prefab is at the correct position and if it fails, it will provide the expected postion and the actual postion of the entity in the Editor log
-    new_prefab_position = azlmbr.components.TransformBus(azlmbr.bus.Event, "GetWorldTranslation", container_entity_id)
-    is_at_position = new_prefab_position.IsClose(EXPECTED_NEW_PREFAB_POSITION)
-    Report.result(Tests.new_prefab_position, is_at_position)
+    actual_prefab_position = azlmbr.components.TransformBus(azlmbr.bus.Event, "GetWorldTranslation", container_entity_id)
+    is_at_position = actual_prefab_position.IsClose(INSTANTIATED_PREFAB_POSITION)
+    Report.result(Tests.instantiated_prefab_position, is_at_position)
     if not is_at_position:
-        Report.info(f'Expected position: {EXPECTED_NEW_PREFAB_POSITION.ToString()}, actual position: {new_prefab_position.ToString()}')
-    
+        Report.info(f'Expected position: {INSTANTIATED_PREFAB_POSITION.ToString()}, actual position: {actual_prefab_position.ToString()}')
+
+# Checks for prefab deletion passed or not 
+    delete_prefab_result = prefab.PrefabPublicRequestBus(bus.Broadcast, 'DeleteEntitiesAndAllDescendantsInInstance', [container_entity_id])
+    Report.result(Tests.delete_prefab, delete_prefab_result.IsSuccess())
+    print_error_if_failed(delete_prefab_result)
+    Report.result(Tests.instantiated_prefab_removed, find_entity_by_name(INSTANTIATED_PREFAB_NAME) is None)
+    Report.result(Tests.instantiated_child_removed, find_entity_by_name(INSTANTIATED_CHILD_ENTITY_NAME) is None)
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp
index 7af953efca..e618a11344 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp
@@ -61,7 +61,7 @@ namespace AzToolsFramework
             m_prefabUndoCache.Destroy();
         }
 
-        PrefabOperationResult PrefabPublicHandler::CreatePrefabInMemory(const AZStd::vector<AZ::EntityId>& entityIds, AZ::IO::PathView filePath)
+        PrefabOperationResult PrefabPublicHandler::CreatePrefabInMemory(const EntityIdList& entityIds, AZ::IO::PathView filePath)
         {
             EntityList inputEntityList, topLevelEntities;
             AZ::EntityId commonRootEntityId;
@@ -264,7 +264,7 @@ namespace AzToolsFramework
             return AZ::Success();
         }
 
-        PrefabOperationResult PrefabPublicHandler::CreatePrefabInDisk(const AZStd::vector<AZ::EntityId>& entityIds, AZ::IO::PathView filePath)
+        PrefabOperationResult PrefabPublicHandler::CreatePrefabInDisk(const EntityIdList& entityIds, AZ::IO::PathView filePath)
         {
             auto result = CreatePrefabInMemory(entityIds, filePath);
             if (result.IsSuccess())
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.h b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.h
index 8f124e8edd..6faaa6932f 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.h
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.h
@@ -43,9 +43,9 @@ namespace AzToolsFramework
 
             // PrefabPublicInterface...
             PrefabOperationResult CreatePrefabInDisk(
-                const AZStd::vector<AZ::EntityId>& entityIds, AZ::IO::PathView filePath) override;
+                const EntityIdList& entityIds, AZ::IO::PathView filePath) override;
             PrefabOperationResult CreatePrefabInMemory(
-                const AZStd::vector<AZ::EntityId>& entityIds, AZ::IO::PathView filePath) override;
+                const EntityIdList& entityIds, AZ::IO::PathView filePath) override;
             InstantiatePrefabResult InstantiatePrefab(AZStd::string_view filePath, AZ::EntityId parent, const AZ::Vector3& position) override;
             PrefabOperationResult SavePrefab(AZ::IO::Path filePath) override;
             PrefabEntityResult CreateEntity(AZ::EntityId parentId, const AZ::Vector3& position) override;
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicInterface.h b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicInterface.h
index 67d65dfca6..83763ef55f 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicInterface.h
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicInterface.h
@@ -47,7 +47,7 @@ namespace AzToolsFramework
              * @return An outcome object; on failure, it comes with an error message detailing the cause of the error.
              */
             virtual PrefabOperationResult CreatePrefabInDisk(
-                const AZStd::vector<AZ::EntityId>& entityIds, AZ::IO::PathView filePath) = 0;
+                const EntityIdList& entityIds, AZ::IO::PathView filePath) = 0;
 
             /**
              * Create a prefab out of the entities provided, at the path provided, and keep it in memory.
@@ -57,7 +57,7 @@ namespace AzToolsFramework
              * @return An outcome object; on failure, it comes with an error message detailing the cause of the error.
              */
             virtual PrefabOperationResult CreatePrefabInMemory(
-                const AZStd::vector<AZ::EntityId>& entityIds, AZ::IO::PathView filePath) = 0;
+                const EntityIdList& entityIds, AZ::IO::PathView filePath) = 0;
 
             /**
              * Instantiate a prefab from a prefab file.
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicRequestBus.h b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicRequestBus.h
index 1b86d3cd4e..1605ad97be 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicRequestBus.h
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicRequestBus.h
@@ -11,13 +11,20 @@
 #include <AzCore/Component/EntityId.h>
 #include <AzCore/EBus/EBus.h>
 #include <AzCore/Math/Vector3.h>
+#include <AzCore/Outcome/Outcome.h>
 #include <AzCore/std/containers/vector.h>
+#include <AzCore/std/string/string.h>
 #include <AzCore/std/string/string_view.h>
 
 namespace AzToolsFramework
 {
+    using EntityIdList = AZStd::vector<AZ::EntityId>;
+
     namespace Prefab
     {
+        using PrefabOperationResult = AZ::Outcome<void, AZStd::string>;
+        using InstantiatePrefabResult = AZ::Outcome<AZ::EntityId, AZStd::string>;
+
         /**
         * The primary purpose of this bus is to facilitate writing automated tests for prefabs.
         * It calls PrefabPublicInterface internally to talk to the prefab system.
@@ -40,14 +47,25 @@ namespace AzToolsFramework
             /**
              * Create a prefab out of the entities provided, at the path provided, and keep it in memory.
              * Automatically detects descendants of entities, and discerns between entities and child instances.
+             * Return whether the creation succeeded or not.
              */
-            virtual bool CreatePrefabInMemory(
-                const AZStd::vector<AZ::EntityId>& entityIds, AZStd::string_view filePath) = 0;
+            virtual PrefabOperationResult CreatePrefabInMemory(
+                const EntityIdList& entityIds, AZStd::string_view filePath) = 0;
 
             /**
              * Instantiate a prefab from a prefab file.
+             * Return the container entity id of the prefab instantiated if instantiation succeeded.
              */
-            virtual AZ::EntityId InstantiatePrefab(AZStd::string_view filePath, AZ::EntityId parent, const AZ::Vector3& position) = 0;
+            virtual InstantiatePrefabResult InstantiatePrefab(
+                AZStd::string_view filePath, AZ::EntityId parent, const AZ::Vector3& position) = 0;
+
+            /**
+             * Deletes all entities and their descendants from the owning instance. Bails if the entities don't
+             * all belong to the same instance.
+             * Return whether the deletion succeeded or not.
+             */
+            virtual PrefabOperationResult DeleteEntitiesAndAllDescendantsInInstance(const EntityIdList& entityIds) = 0;
+
         };
 
         using PrefabPublicRequestBus = AZ::EBus<PrefabPublicRequests>;
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicRequestHandler.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicRequestHandler.cpp
index 0e68a286a6..d964be25af 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicRequestHandler.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicRequestHandler.cpp
@@ -25,6 +25,7 @@ namespace AzToolsFramework
                     ->Attribute(AZ::Script::Attributes::Module, "prefab")
                     ->Event("CreatePrefabInMemory", &PrefabPublicRequests::CreatePrefabInMemory)
                     ->Event("InstantiatePrefab", &PrefabPublicRequests::InstantiatePrefab)
+                    ->Event("DeleteEntitiesAndAllDescendantsInInstance", &PrefabPublicRequests::DeleteEntitiesAndAllDescendantsInInstance)
                     ;
             }
         }
@@ -44,36 +45,20 @@ namespace AzToolsFramework
             m_prefabPublicInterface = nullptr;
         }
 
-        bool PrefabPublicRequestHandler::CreatePrefabInMemory(const AZStd::vector<AZ::EntityId>& entityIds, AZStd::string_view filePath)
+        PrefabOperationResult PrefabPublicRequestHandler::CreatePrefabInMemory(const EntityIdList& entityIds, AZStd::string_view filePath)
         {
-            auto createPrefabOutcome = m_prefabPublicInterface->CreatePrefabInMemory(entityIds, filePath);
-            if (!createPrefabOutcome.IsSuccess())
-            {
-                AZ_Error("CreatePrefabInMemory", false,
-                    "Failed to create Prefab on file path '%.*s'. Error message: %s.",
-                    AZ_STRING_ARG(filePath),
-                    createPrefabOutcome.GetError().c_str());
-
-                return false;
-            }
-
-            return true;
+            return m_prefabPublicInterface->CreatePrefabInMemory(entityIds, filePath);
         }
 
-        AZ::EntityId PrefabPublicRequestHandler::InstantiatePrefab(AZStd::string_view filePath, AZ::EntityId parent, const AZ::Vector3& position)
+        InstantiatePrefabResult PrefabPublicRequestHandler::InstantiatePrefab(AZStd::string_view filePath, AZ::EntityId parent, const AZ::Vector3& position)
         {
-            auto instantiatePrefabOutcome = m_prefabPublicInterface->InstantiatePrefab(filePath, parent, position);
-            if (!instantiatePrefabOutcome.IsSuccess())
-            {
-                AZ_Error("InstantiatePrefab", false,
-                    "Failed to instantiate Prefab on file path '%.*s'. Error message: %s.",
-                    AZ_STRING_ARG(filePath),
-                    instantiatePrefabOutcome.GetError().c_str());
-
-                return AZ::EntityId();
-            }
-
-            return instantiatePrefabOutcome.GetValue();
+            return m_prefabPublicInterface->InstantiatePrefab(filePath, parent, position);
         }
+
+        PrefabOperationResult PrefabPublicRequestHandler::DeleteEntitiesAndAllDescendantsInInstance(const EntityIdList& entityIds)
+        {
+            return m_prefabPublicInterface->DeleteEntitiesAndAllDescendantsInInstance(entityIds);
+        }
+
     } // namespace Prefab
 } // namespace AzToolsFramework
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicRequestHandler.h b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicRequestHandler.h
index 548bc8e04a..87608e1263 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicRequestHandler.h
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicRequestHandler.h
@@ -31,8 +31,9 @@ namespace AzToolsFramework
             void Connect();
             void Disconnect();
 
-            bool CreatePrefabInMemory(const AZStd::vector<AZ::EntityId>& entityIds, AZStd::string_view filePath) override;
-            AZ::EntityId InstantiatePrefab(AZStd::string_view filePath, AZ::EntityId parent, const AZ::Vector3& position) override;
+            PrefabOperationResult CreatePrefabInMemory(const EntityIdList& entityIds, AZStd::string_view filePath) override;
+            InstantiatePrefabResult InstantiatePrefab(AZStd::string_view filePath, AZ::EntityId parent, const AZ::Vector3& position) override;
+            PrefabOperationResult DeleteEntitiesAndAllDescendantsInInstance(const EntityIdList& entityIds) override;
 
         private:
             PrefabPublicInterface* m_prefabPublicInterface = nullptr;

From 8589bb99de0b1e0d50881ded01adddaa64895c34 Mon Sep 17 00:00:00 2001
From: Mikhail Naumov <mnaumov@amazon.com>
Date: Wed, 18 Aug 2021 12:01:07 -0700
Subject: [PATCH 21/37] cleaned up comments

Signed-off-by: Mikhail Naumov <mnaumov@amazon.com>
---
 .../AzToolsFramework/UI/Prefab/PrefabIntegrationManager.cpp   | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/Prefab/PrefabIntegrationManager.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/Prefab/PrefabIntegrationManager.cpp
index 7f3fbbeb38..9f75abb32a 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/Prefab/PrefabIntegrationManager.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/Prefab/PrefabIntegrationManager.cpp
@@ -367,17 +367,17 @@ namespace AzToolsFramework
                 AZ::EntityId parentId;
                 AZ::Vector3 position = AZ::Vector3::CreateZero();
 
-                // if one entity is selected, set it as parent
                 EntityIdList selectedEntities;
                 ToolsApplicationRequestBus::BroadcastResult(selectedEntities, &ToolsApplicationRequests::GetSelectedEntities);
+                // if one entity is selected, instantiate prefab as its child and place it at same position as parent
                 if (selectedEntities.size() == 1)
                 {
                     parentId = selectedEntities.front();
                     AZ::TransformBus::EventResult(position, parentId, &AZ::TransformInterface::GetWorldTranslation);
                 }
+                // otherwise instantiate it at root level and center of viewport
                 else
                 {
-                    // Get position (center of viewport). If no viewport is available, (0,0,0) will be used.
                     EditorRequestBus::BroadcastResult(position, &EditorRequestBus::Events::GetWorldPositionAtViewportCenter);
                 }
 

From 3f31a6f8bf3c260d2801bc3a8036acfceb5c99dc Mon Sep 17 00:00:00 2001
From: Esteban Papp <81431996+amznestebanpapp@users.noreply.github.com>
Date: Wed, 18 Aug 2021 12:38:00 -0700
Subject: [PATCH 22/37] Remove crcfix (#3294)

Signed-off-by: Esteban Papp <81431996+amznestebanpapp@users.noreply.github.com>
---
 Code/Framework/CMakeLists.txt                 |   1 -
 Code/Framework/Crcfix/CMakeLists.txt          |  32 --
 .../Crcfix/Platform/Linux/PAL_linux.cmake     |   9 -
 .../Crcfix/Platform/Mac/PAL_mac.cmake         |   9 -
 .../Crcfix/Platform/Windows/PAL_windows.cmake |   9 -
 Code/Framework/Crcfix/crcfix.cpp              | 538 ------------------
 Code/Framework/Crcfix/crcfix_files.cmake      |  11 -
 7 files changed, 609 deletions(-)
 delete mode 100644 Code/Framework/Crcfix/CMakeLists.txt
 delete mode 100644 Code/Framework/Crcfix/Platform/Linux/PAL_linux.cmake
 delete mode 100644 Code/Framework/Crcfix/Platform/Mac/PAL_mac.cmake
 delete mode 100644 Code/Framework/Crcfix/Platform/Windows/PAL_windows.cmake
 delete mode 100644 Code/Framework/Crcfix/crcfix.cpp
 delete mode 100644 Code/Framework/Crcfix/crcfix_files.cmake

diff --git a/Code/Framework/CMakeLists.txt b/Code/Framework/CMakeLists.txt
index 61f65de5a4..8cc02fd4e8 100644
--- a/Code/Framework/CMakeLists.txt
+++ b/Code/Framework/CMakeLists.txt
@@ -15,6 +15,5 @@ add_subdirectory(AzTest)
 add_subdirectory(AzToolsFramework)
 add_subdirectory(AzManipulatorTestFramework)
 add_subdirectory(AzNetworking)
-add_subdirectory(Crcfix)
 add_subdirectory(GFxFramework)
 add_subdirectory(GridMate)
diff --git a/Code/Framework/Crcfix/CMakeLists.txt b/Code/Framework/Crcfix/CMakeLists.txt
deleted file mode 100644
index 4fdad1e338..0000000000
--- a/Code/Framework/Crcfix/CMakeLists.txt
+++ /dev/null
@@ -1,32 +0,0 @@
-#
-# Copyright (c) Contributors to the Open 3D Engine Project.
-# For complete copyright and license terms please see the LICENSE at the root of this distribution.
-#
-# SPDX-License-Identifier: Apache-2.0 OR MIT
-#
-#
-
-if (NOT PAL_TRAIT_BUILD_HOST_TOOLS)
-    return()
-endif()
-
-include(Platform/${PAL_PLATFORM_NAME}/PAL_${PAL_PLATFORM_NAME_LOWERCASE}.cmake)
-if (NOT PAL_TRAIT_BUILD_CRCFIX)
-    return()
-endif()
-
-ly_add_target(
-    NAME Crcfix EXECUTABLE
-    NAMESPACE AZ
-    FILES_CMAKE
-        crcfix_files.cmake
-    BUILD_DEPENDENCIES
-        PRIVATE
-            AZ::AzCore
-)
-
-ly_add_source_properties(
-    SOURCES crcfix.cpp
-    PROPERTY COMPILE_DEFINITIONS
-    VALUES _CRT_SECURE_NO_WARNINGS
-)
diff --git a/Code/Framework/Crcfix/Platform/Linux/PAL_linux.cmake b/Code/Framework/Crcfix/Platform/Linux/PAL_linux.cmake
deleted file mode 100644
index a63f2bed45..0000000000
--- a/Code/Framework/Crcfix/Platform/Linux/PAL_linux.cmake
+++ /dev/null
@@ -1,9 +0,0 @@
-#
-# Copyright (c) Contributors to the Open 3D Engine Project.
-# For complete copyright and license terms please see the LICENSE at the root of this distribution.
-#
-# SPDX-License-Identifier: Apache-2.0 OR MIT
-#
-#
-
-set(PAL_TRAIT_BUILD_CRCFIX FALSE)
diff --git a/Code/Framework/Crcfix/Platform/Mac/PAL_mac.cmake b/Code/Framework/Crcfix/Platform/Mac/PAL_mac.cmake
deleted file mode 100644
index a63f2bed45..0000000000
--- a/Code/Framework/Crcfix/Platform/Mac/PAL_mac.cmake
+++ /dev/null
@@ -1,9 +0,0 @@
-#
-# Copyright (c) Contributors to the Open 3D Engine Project.
-# For complete copyright and license terms please see the LICENSE at the root of this distribution.
-#
-# SPDX-License-Identifier: Apache-2.0 OR MIT
-#
-#
-
-set(PAL_TRAIT_BUILD_CRCFIX FALSE)
diff --git a/Code/Framework/Crcfix/Platform/Windows/PAL_windows.cmake b/Code/Framework/Crcfix/Platform/Windows/PAL_windows.cmake
deleted file mode 100644
index 8a8884139d..0000000000
--- a/Code/Framework/Crcfix/Platform/Windows/PAL_windows.cmake
+++ /dev/null
@@ -1,9 +0,0 @@
-#
-# Copyright (c) Contributors to the Open 3D Engine Project.
-# For complete copyright and license terms please see the LICENSE at the root of this distribution.
-#
-# SPDX-License-Identifier: Apache-2.0 OR MIT
-#
-#
-
-set(PAL_TRAIT_BUILD_CRCFIX TRUE)
diff --git a/Code/Framework/Crcfix/crcfix.cpp b/Code/Framework/Crcfix/crcfix.cpp
deleted file mode 100644
index 778b9e2185..0000000000
--- a/Code/Framework/Crcfix/crcfix.cpp
+++ /dev/null
@@ -1,538 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#include <AzCore/PlatformIncl.h>
-#include <AzCore/Math/Crc.h>
-#include <AzCore/std/string/string.h>
-#include <AzCore/std/containers/vector.h>
-#include <AzCore/Memory/SystemAllocator.h>
-#include <AzCore/Memory/AllocationRecords.h>
-#include <AzCore/std/chrono/chrono.h>
-#include <AzCore/std/string/conversions.h>
-#include <AzCore/Utils/Utils.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <io.h>
-#include <sys/stat.h>
-
-int g_totalFixTimeMs = 0;
-int g_longestFixTimeMs = 0;
-
-class Filename
-{
-    wchar_t    fullpath[MAX_PATH];
-    wchar_t    drive[_MAX_DRIVE];
-    wchar_t    dir[_MAX_DIR];
-    wchar_t    fname[_MAX_FNAME];
-    wchar_t    ext[_MAX_EXT];
-
-public:
-    Filename()
-    {
-        fullpath[0] = drive[0] = dir[0] = fname[0] = ext[0] = 0;
-    }
-
-    Filename(const AZStd::wstring& filename)
-    {
-        _wsplitpath(filename.c_str(), drive, dir, fname, ext);
-        wcscpy(fullpath, filename.c_str());
-    }
-
-    void        SetExt(const wchar_t* pExt)     { wcscpy(ext, pExt); _wmakepath(fullpath, drive, dir, fname, pExt); }
-    const wchar_t* GetFullPath() const          { return fullpath; }
-    bool        Exists() const                  { return _waccess(fullpath, 0) == 0; }
-    bool        IsReadOnly() const              { return _waccess(fullpath, 6) == -1; }
-    bool        SetReadOnly() const             { return _wchmod(fullpath, _S_IREAD) == 0; }
-    bool        SetWritable() const             { return _wchmod(fullpath, _S_IREAD | _S_IWRITE) == 0; }
-    bool        Delete() const                  { return _wremove(fullpath) == 0; }
-    bool        Rename(const wchar_t* fn2) const{ return MoveFileEx(fullpath, fn2, MOVEFILE_COPY_ALLOWED|MOVEFILE_REPLACE_EXISTING) == 0; }
-    bool        Copy(const wchar_t* dest) const { return ::CopyFile(fullpath, dest, FALSE) == TRUE; }
-};
-
-class CRCfix
-{
-    int             lastchar;
-    int             linenum;
-
-public:
-    void    SkipToEOL(FILE* infile);
-    char*   GetToken(FILE* infile, FILE* outfile);
-    void    GetPreviousCRC(char* token, FILE* infile);
-    int     Fix(Filename srce);
-};
-
-void FixFiles(const AZStd::wstring& dir, const AZStd::wstring& files, FILETIME* pLastRun, bool verbose, int& nFound, int& nProcessed, int& nFixed, int& nFailed)
-{
-    CRCfix fixer;
-    WIN32_FIND_DATA wfd;
-    HANDLE hFind;
-    hFind = FindFirstFile((dir + files).c_str(), &wfd);
-    if (hFind != INVALID_HANDLE_VALUE)
-    {
-        do
-        {
-            if ((wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
-            {
-                if (verbose)
-                {
-                    AZ_TracePrintf("CrcFix", "\tProcessing %ls ...", wfd.cFileName);
-                }
-                nFound++;
-
-                int n = 0;
-                if ((wfd.dwFileAttributes & FILE_ATTRIBUTE_READONLY) == 0 && (!pLastRun || CompareFileTime(pLastRun, &wfd.ftLastWriteTime) <= 0))
-                {
-                    n = fixer.Fix(Filename(dir + L"\\" + wfd.cFileName));
-                    nProcessed++;
-                }
-                if (n < 0)
-                {
-                    nFailed++;
-                    if (verbose)
-                    {
-                        AZ_TracePrintf("CrcFix", "Failed\n");
-                    }
-                }
-                else
-                {
-                    if (verbose)
-                    {
-                        AZ_TracePrintf("CrcFix", n > 0 ? "Done\n" : (wfd.dwFileAttributes & FILE_ATTRIBUTE_READONLY) != 0 ? "ReadOnly\n" : "Unchanged\n");
-                    }
-                    nFixed += n;
-                }
-            }
-        } while (FindNextFile(hFind, &wfd));
-    }
-    FindClose(hFind);
-}
-
-void FixDirectories(const AZStd::wstring& dirs, const AZStd::wstring& files, FILETIME* pLastRun, bool verbose, int& nFound, int& nProcessed, int& nFixed, int& nFailed)
-{
-    if (verbose)
-    {
-        AZ_TracePrintf("CrcFix", "Processing %ls ...\n", dirs.c_str());
-    }
-
-    // do files
-    FixFiles(dirs, files, pLastRun, verbose, nFound, nProcessed, nFixed, nFailed);
-
-    // do folders
-    WIN32_FIND_DATA wfd;
-    HANDLE hFind;
-    hFind = FindFirstFile((dirs + L"\\*").c_str(), &wfd);
-    if (hFind != INVALID_HANDLE_VALUE)
-    {
-        do
-        {
-            if ((wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY)
-            {
-                if (wfd.cFileName[0] == '.')
-                {
-                    continue;
-                }
-                FixDirectories(AZStd::wstring(dirs + L"\\" + wfd.cFileName), files, pLastRun, verbose, nFound, nProcessed, nFixed, nFailed);
-            }
-        } while (FindNextFile(hFind, &wfd));
-    }
-    FindClose(hFind);
-}
-
-int main(int argc, char* argv[])
-{
-    AZStd::chrono::system_clock::time_point startTime = AZStd::chrono::system_clock::now();
-
-    AZ::SystemAllocator::Descriptor desc;
-    //desc.m_stackRecordLevels = 15;
-    AZ::AllocatorInstance<AZ::SystemAllocator>::Create(desc);
-    //if (AZ::AllocatorInstance<AZ::SystemAllocator>::Get().GetRecords()) {
-    //  AZ::AllocatorInstance<AZ::SystemAllocator>::Get().GetRecords()->SetMode(AZ::Debug::AllocationRecords::RECORD_FULL);
-    //}
-    {
-        if (argc < 2)
-        {
-            AZ_TracePrintf("CrcFix", "Usage:\n  crcfix [-v(erbose)] [-log:logfile] {path[\\*][\\*.*]}\n");
-            AZ_TracePrintf("CrcFix", "\n  Ex:\n    crcfix -v -log:timestamp.log src\\*\\*.cpp src\\*\\*.h ..\\scripts\\*.*\n\n");
-        }
-
-        char root[MAX_PATH];
-        AZ::Utils::GetExecutableDirectory(root, MAX_PATH);
-
-        AZStd::vector<AZStd::wstring> entries;
-
-        AZStd::wstring logfilename;
-        FILETIME    lastRun;
-        FILETIME* pLastRun = NULL;
-
-        bool verbose = false;
-
-        for (int iArg = 1; iArg < argc; ++iArg)
-        {
-            const char* pArg = argv[iArg];
-            if (!pArg)
-            {
-                continue;
-            }
-            AZStd::wstring pArgW;
-            AZStd::to_wstring(pArgW, pArg);
-            if (_strnicmp(pArg, "-log:", 5) == 0)
-            {
-                logfilename.assign(pArgW.begin() + 5, pArgW.end());
-                HANDLE hFile = CreateFile(logfilename.data(), 0, 0, NULL, OPEN_EXISTING, 0, NULL);
-                if (hFile != INVALID_HANDLE_VALUE)
-                {
-                    pLastRun = &lastRun;
-                    GetFileTime(hFile, NULL, NULL, pLastRun);
-                    CloseHandle(hFile);
-                }
-            }
-            else if (_stricmp(pArg, "-v") == 0)
-            {
-                verbose = true;
-            }
-            else
-            {
-                entries.emplace_back(AZStd::move(pArgW));
-            }
-        }
-
-        // for each entry from the command line...
-        int nFound = 0;
-        int nProcessed = 0;
-        int nFixed = 0;
-        int nFailed = 0;
-        for (AZStd::vector<AZStd::wstring>::const_iterator iEntry = entries.begin(); iEntry != entries.end(); ++iEntry)
-        {
-            AZStd::wstring entry = (iEntry->at(0) == L'\\' || iEntry->find(L":") != iEntry->npos) ? *iEntry : AZStd::wstring(root) + L"\\" + *iEntry;
-            AZStd::wstring::size_type split = entry.find(L"*\\");
-            bool doSubdirs = split != entry.npos;
-            if (doSubdirs)
-            {
-                FixDirectories(entry.substr(0, split), entry.substr(split + 1), pLastRun, verbose, nFound, nProcessed, nFixed, nFailed);
-            }
-            else
-            {
-                split = entry.rfind(L"\\");
-                if (split == entry.npos)
-                {
-                    split = 0;
-                }
-                FixFiles(entry.substr(0, split), entry.substr(split), pLastRun, verbose, nFound, nProcessed, nFixed, nFailed);
-            }
-        }
-
-        // update timestamp
-        if (!logfilename.empty())
-        {
-            HANDLE      hFile = CreateFile(logfilename.data(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
-            GetSystemTimeAsFileTime(&lastRun);
-            SetFileTime(hFile, NULL, NULL, &lastRun);
-            char log[1024];
-            DWORD oCount;
-
-            sprintf(log, "Batches processed: %zu\n\tFiles found: %d\n\tFiles processed: %d\n\tFiles fixed: %d\n\tFiles failed: %d\n", entries.size(), nFound, nProcessed, nFixed, nFailed);
-            WriteFile(hFile, log, static_cast<DWORD>(strlen(log)), &oCount, NULL);
-
-            AZStd::chrono::system_clock::time_point endTime = AZStd::chrono::system_clock::now();
-            sprintf(log, "Total running time: %.2f secs.\n\tTotal processing time: %.2f secs.\n\tLongest processing time: %.2f secs.\n", (float)AZStd::chrono::milliseconds(endTime - startTime).count() / 1000.f, (float)g_totalFixTimeMs / 1000.f, (float)g_longestFixTimeMs / 1000.f);
-            WriteFile(hFile, log, static_cast<DWORD>(strlen(log)), &oCount, NULL);
-
-            CloseHandle(hFile);
-        }
-    }
-
-    AZ::AllocatorInstance<AZ::SystemAllocator>::Destroy();
-    return 0;
-}
-
-//-----------------------------------------------------------------------------
-// CRCfix
-//-----------------------------------------------------------------------------
-void CRCfix::SkipToEOL(FILE* infile)
-{
-    int     c;
-    for (c = lastchar; c != EOF && c != '\n'; c = fgetc(infile))
-    {
-        ;
-    }
-    lastchar = fgetc(infile);
-    linenum++;
-}
-//-----------------------------------------------------------------------------
-char* CRCfix::GetToken(FILE* infile, FILE* outfile)
-{
-    static char token[512];
-    bool    commentline     = false;
-    bool    commentblock    = false;
-    bool    doublequote     = false;
-    bool    singlequote     = false;
-    int     i               = 0;
-    int     c;
-
-    if (lastchar == EOF)
-    {
-        return NULL;
-    }
-
-    for (c = lastchar; c != EOF; c = fgetc(infile))
-    {
-        if (!commentline && !commentblock && !doublequote && !singlequote)
-        {
-            if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '#' || c == '_')
-            {
-                token[i++] = c;
-                continue;
-            }
-            else
-            {
-                if (i)
-                {
-                    lastchar    = c;
-                    token[i]    = 0;
-                    i           = 0;
-                    return token;
-                }
-            }
-        }
-
-        if (commentline)
-        {
-            if (c == '\n')
-            {
-                commentline = false;
-            }
-        }
-        else if (commentblock)
-        {
-            while (c == '*')
-            {
-                c = fgetc(infile);
-                if (c == '/')
-                {
-                    commentblock = false;
-                }
-                fputc('*', outfile);
-            }
-        }
-
-        if (!commentline && !commentblock)
-        {
-            if (c == '"' && !singlequote)
-            {
-                doublequote = !doublequote;
-            }
-            else if (c == '\'' && !doublequote)
-            {
-                singlequote = !singlequote;
-            }
-            else if (!singlequote && !doublequote)
-            {
-                if (c == '/')
-                {
-                    c = fgetc(infile);
-                    if (c == '/')
-                    {
-                        commentline = true;
-                    }
-                    else if (c == '*')
-                    {
-                        commentblock = true;
-                    }
-                    if (c == '\'')
-                    {
-                        singlequote = true;
-                    }
-                    else if (c == '"')
-                    {
-                        doublequote = true;
-                    }
-                    fputc('/', outfile);
-                }
-            }
-            else if (c == '\\')
-            {
-                fputc(c, outfile);
-                c = fgetc(infile);
-            }
-        }
-        fputc(c, outfile);
-        if (c == '\n')
-        {
-            linenum++;
-        }
-    }
-    lastchar = c;
-    token[i] = 0;
-    return i ? token : NULL;
-}
-//-----------------------------------------------------------------------------
-void CRCfix::GetPreviousCRC(char* token, FILE* infile)
-{
-    int     c;
-    while ((c = fgetc(infile)) != ')')
-    {
-        *token++ = c;
-    }
-    *token = 0;
-}
-//-----------------------------------------------------------------------------
-int CRCfix::Fix(Filename srce)
-{
-    AZStd::chrono::system_clock::time_point startTime = AZStd::chrono::system_clock::now();
-
-    bool        changed = false;
-    Filename    dest(srce);
-    dest.SetExt(L"xxx");
-
-    linenum = 0;
-
-    FILE* infile = _wfopen(srce.GetFullPath(), L"r");
-    FILE* outfile = _wfopen(dest.GetFullPath(), L"w");
-
-    if (!infile || !outfile)
-    {
-        if (infile)
-        {
-            fclose(infile);
-            infile = nullptr;
-        }
-
-        if (outfile)
-        {
-            fclose(outfile);
-            outfile = nullptr;
-        }
-
-        int dt = static_cast<int>(AZStd::chrono::milliseconds(AZStd::chrono::system_clock::now() - startTime).count());
-        g_totalFixTimeMs += dt;
-        if (dt > g_longestFixTimeMs)
-        {
-            g_longestFixTimeMs = dt;
-        }
-
-        return -1;
-    }
-
-    lastchar    = fgetc(infile);
-
-    while (char* token = GetToken(infile, outfile))
-    {
-        bool    got = false;
-
-        if (strcmp(token, "AZ_CRC") == 0 && lastchar == '(')
-        {
-            size_t  i   = strlen(token);
-            token[i++]  = lastchar;
-            int     c   = fgetc(infile);
-
-            if (c == '"')
-            {
-                size_t j = i + 1;
-
-                do
-                {
-                    token[i++] = c;
-                    c = fgetc(infile);
-                } while (c != '"');
-
-                token[i++] = c;
-                c = fgetc(infile);
-
-                int oldcrc = 0, newcrc;
-
-                if (c == ',')
-                {
-                    GetPreviousCRC(token + i, infile);
-                    sscanf(token + i, "%i", &oldcrc);
-                    c = ')';
-                }
-
-                if (c == ')')
-                {
-                    token[i]    = 0;
-                    c           = fgetc(infile);
-                    got         = true;
-                    newcrc      = AZ::Crc32(token + j, i - j - 1, true);
-                    fprintf(outfile, "%s, 0x%08x)", token, newcrc);
-                    if (newcrc != oldcrc)
-                    {
-                        changed = true;
-                    }
-                }
-            }
-            lastchar    = c;
-            token[i]    = 0;
-        }
-        if (!got)
-        {
-            fwrite(token, 1, strlen(token), outfile);
-        }
-    }
-    fclose(infile);
-    fclose(outfile);
-
-    if (changed)
-    {
-        Filename    backup(srce);
-        backup.SetExt(L"crcfix_old");
-
-        if (backup.Exists())
-        {
-            backup.SetWritable();
-            [[maybe_unused]] bool deleted = backup.Delete();
-            AZ_Assert(deleted, "failed to delete");
-        }
-
-        if (!srce.Copy(backup.GetFullPath()))
-        {
-            AZ_TracePrintf("CrcFix", "Failed to copy %ls to %ls\n", srce, backup);
-
-            int dt = static_cast<int>(AZStd::chrono::milliseconds(AZStd::chrono::system_clock::now() - startTime).count());
-            g_totalFixTimeMs += dt;
-            if (dt > g_longestFixTimeMs)
-            {
-                g_longestFixTimeMs = dt;
-            }
-
-            return -1;
-        }
-
-        if (!dest.Rename(srce.GetFullPath()))
-        {
-            AZ_TracePrintf("CrcFix", "Failed to rename %ls to %ls\n", dest, srce);
-
-            int dt = static_cast<int>(AZStd::chrono::milliseconds(AZStd::chrono::system_clock::now() - startTime).count());
-            g_totalFixTimeMs += dt;
-            if (dt > g_longestFixTimeMs)
-            {
-                g_longestFixTimeMs = dt;
-            }
-
-            return -1;
-        }
-
-        if (!backup.Delete())
-        {
-            AZ_TracePrintf("CrcFix", "Failed to delete %ls\n", backup);
-        }
-    }
-    else
-    {
-        dest.Delete();
-    }
-
-
-    int dt = static_cast<int>(AZStd::chrono::milliseconds(AZStd::chrono::system_clock::now() - startTime).count());
-    g_totalFixTimeMs += dt;
-    if (dt > g_longestFixTimeMs)
-    {
-        g_longestFixTimeMs = dt;
-    }
-
-    return changed ? 1 : 0;
-}
-//-----------------------------------------------------------------------------
diff --git a/Code/Framework/Crcfix/crcfix_files.cmake b/Code/Framework/Crcfix/crcfix_files.cmake
deleted file mode 100644
index d170013e67..0000000000
--- a/Code/Framework/Crcfix/crcfix_files.cmake
+++ /dev/null
@@ -1,11 +0,0 @@
-#
-# Copyright (c) Contributors to the Open 3D Engine Project.
-# For complete copyright and license terms please see the LICENSE at the root of this distribution.
-#
-# SPDX-License-Identifier: Apache-2.0 OR MIT
-#
-#
-
-set(FILES crcfix_files.cmake
-    crcfix.cpp
-)

From 749ff5df74468e0add57253c7bbc0b6e2e28f106 Mon Sep 17 00:00:00 2001
From: AMZN-nggieber <52797929+AMZN-nggieber@users.noreply.github.com>
Date: Wed, 18 Aug 2021 13:37:19 -0700
Subject: [PATCH 23/37] Pressing Enter/Return Key While File Browse Widget is
 Focused Opens File Browser (#3304)

* Pressing enter or return opens file browse dialog on browse edit widgets

Signed-off-by: nggieber <nggieber@amazon.com>

* Remove unused header

Signed-off-by: nggieber <nggieber@amazon.com>
---
 .../ProjectManager/Source/FormBrowseEditWidget.cpp    | 11 +++++++++++
 .../ProjectManager/Source/FormBrowseEditWidget.h      |  3 +++
 .../Source/FormFolderBrowseEditWidget.cpp             |  2 +-
 3 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/Code/Tools/ProjectManager/Source/FormBrowseEditWidget.cpp b/Code/Tools/ProjectManager/Source/FormBrowseEditWidget.cpp
index 9cfc6461c2..8cd28fcbb4 100644
--- a/Code/Tools/ProjectManager/Source/FormBrowseEditWidget.cpp
+++ b/Code/Tools/ProjectManager/Source/FormBrowseEditWidget.cpp
@@ -10,6 +10,7 @@
 
 #include <QPushButton>
 #include <QHBoxLayout>
+#include <QKeyEvent>
 
 namespace O3DE::ProjectManager
 {
@@ -27,4 +28,14 @@ namespace O3DE::ProjectManager
         : FormBrowseEditWidget(labelText, "", parent)
     {
     }
+
+    void FormBrowseEditWidget::keyPressEvent(QKeyEvent* event)
+    {
+        int key = event->key();
+        if (key == Qt::Key_Return || key == Qt::Key_Enter)
+        {
+            HandleBrowseButton();
+        }
+    }
+
 } // namespace O3DE::ProjectManager
diff --git a/Code/Tools/ProjectManager/Source/FormBrowseEditWidget.h b/Code/Tools/ProjectManager/Source/FormBrowseEditWidget.h
index 7ec2865240..a1f6948ce9 100644
--- a/Code/Tools/ProjectManager/Source/FormBrowseEditWidget.h
+++ b/Code/Tools/ProjectManager/Source/FormBrowseEditWidget.h
@@ -24,6 +24,9 @@ namespace O3DE::ProjectManager
         explicit FormBrowseEditWidget(const QString& labelText = "", QWidget* parent = nullptr);
         ~FormBrowseEditWidget() = default;
 
+    protected:
+        void keyPressEvent(QKeyEvent* event) override;
+
     protected slots:
         virtual void HandleBrowseButton() = 0;
     };
diff --git a/Code/Tools/ProjectManager/Source/FormFolderBrowseEditWidget.cpp b/Code/Tools/ProjectManager/Source/FormFolderBrowseEditWidget.cpp
index 86f46400b3..4101f02c9b 100644
--- a/Code/Tools/ProjectManager/Source/FormFolderBrowseEditWidget.cpp
+++ b/Code/Tools/ProjectManager/Source/FormFolderBrowseEditWidget.cpp
@@ -34,7 +34,6 @@ namespace O3DE::ProjectManager
         {
             setText(directory);
         }
-
     }
 
     void FormFolderBrowseEditWidget::setText(const QString& text)
@@ -42,4 +41,5 @@ namespace O3DE::ProjectManager
         QString path = QDir::toNativeSeparators(text);
         FormBrowseEditWidget::setText(path);
     }
+
 } // namespace O3DE::ProjectManager

From e15ae750a2d87061506fc7d516f7419a4d7c66df Mon Sep 17 00:00:00 2001
From: AMZN-tpeng <82184807+AMZN-tpeng@users.noreply.github.com>
Date: Wed, 18 Aug 2021 13:43:16 -0700
Subject: [PATCH 24/37] =?UTF-8?q?[ATOm][RHI][Vulkan][Android]=20-=20Reorga?=
 =?UTF-8?q?nize=20float2=20data=20members=20to=20floa=E2=80=A6=20(#2718)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* [ATOm][RHI][Vulkan][Android] - Reorganize float2 data members to float to avoid Android Mali GPUdriver crashes

Signed-off-by: Peng <tonypeng@amazon.com>

* [ATOM][RHI][Vulkan][Android] - Added reason comment for modifying float2 in the shader

Signed-off-by: Peng <tonypeng@amazon.com>
---
 .../Assets/Shaders/PostProcessing/SMAA.azsli  | 33 ++++++++++---------
 1 file changed, 18 insertions(+), 15 deletions(-)

diff --git a/Gems/Atom/Feature/Common/Assets/Shaders/PostProcessing/SMAA.azsli b/Gems/Atom/Feature/Common/Assets/Shaders/PostProcessing/SMAA.azsli
index 58c2bc1ce9..8c03816b26 100644
--- a/Gems/Atom/Feature/Common/Assets/Shaders/PostProcessing/SMAA.azsli
+++ b/Gems/Atom/Feature/Common/Assets/Shaders/PostProcessing/SMAA.azsli
@@ -1135,13 +1135,13 @@ float4 SMAABlendingWeightCalculationPS(float2 texcoord,
         if (!o_enableDiagonalDetectionFeature ||
             weights.r == -weights.g) // weights.r + weights.g == 0.0
         {
-            float2 d;
+            // NOTE: using separate floats for (dx, dy) and (sqrt_d_x, sqrt_d_y) instead of float2 due to android Mali driver problem crashing the device
 
             // Find the distance to the left:
             float3 coords;
             coords.x = SMAASearchXLeft(SMAATexturePass2D(edgesTex), SMAATexturePass2D(searchTex), offset[0].xy, offset[2].x);
             coords.y = offset[1].y; // offset[1].y = texcoord.y - 0.25 * SMAA_RT_METRICS.y (@CROSSING_OFFSET)
-            d.x = coords.x;
+            float dx = coords.x;
 
             // Now fetch the left crossing edges, two at a time using bilinear
             // filtering. Sampling at -0.25 (see @CROSSING_OFFSET) enables to
@@ -1150,26 +1150,29 @@ float4 SMAABlendingWeightCalculationPS(float2 texcoord,
 
             // Find the distance to the right:
             coords.z = SMAASearchXRight(SMAATexturePass2D(edgesTex), SMAATexturePass2D(searchTex), offset[0].zw, offset[2].y);
-            d.y = coords.z;
+            float dy = coords.z;
 
             // We want the distances to be in pixel units (doing this here allow to
             // better interleave arithmetic and memory accesses):
-            d = abs(round(mad(SMAA_RT_METRICS.zz, d, -pixcoord.xx)));
+            dx = abs(round(mad(SMAA_RT_METRICS.z, dx, -pixcoord.x)));
+            dy = abs(round(mad(SMAA_RT_METRICS.z, dy, -pixcoord.x)));
 
             // SMAAArea below needs a sqrt, as the areas texture is compressed
             // quadratically:
-            float2 sqrt_d = sqrt(d);
+            float sqrt_d_x = sqrt(dx);
+            float sqrt_d_y = sqrt(dy);
+
 
             // Fetch the right crossing edges:
             float e2 = SMAASampleLevelZeroOffset(edgesTex, coords.zy, int2(1, 0)).r;
 
             // Ok, we know how this pattern looks like, now it is time for getting
             // the actual area:
-            weights.rg = SMAAArea(SMAATexturePass2D(areaTex), sqrt_d, e1, e2, subsampleIndices.y);
+            weights.rg = SMAAArea(SMAATexturePass2D(areaTex), float2(sqrt_d_x, sqrt_d_y), e1, e2, subsampleIndices.y);
 
             // Fix corners:
             coords.y = texcoord.y;
-            SMAADetectHorizontalCornerPattern(SMAATexturePass2D(edgesTex), weights.rg, coords.xyzy, d);
+            SMAADetectHorizontalCornerPattern(SMAATexturePass2D(edgesTex), weights.rg, coords.xyzy, float2(dx, dy));
         }
         else
         {
@@ -1180,37 +1183,37 @@ float4 SMAABlendingWeightCalculationPS(float2 texcoord,
     SMAA_BRANCH
     if (e.r > 0.0) // Edge at west
     {
-        float2 d;
-
         // Find the distance to the top:
         float3 coords;
         coords.y = SMAASearchYUp(SMAATexturePass2D(edgesTex), SMAATexturePass2D(searchTex), offset[1].xy, offset[2].z);
         coords.x = offset[0].x; // offset[1].x = texcoord.x - 0.25 * SMAA_RT_METRICS.x;
-        d.x = coords.y;
+        float dx = coords.y;
 
         // Fetch the top crossing edges:
         float e1 = SMAASampleLevelZero(edgesTex, coords.xy).g;
 
         // Find the distance to the bottom:
         coords.z = SMAASearchYDown(SMAATexturePass2D(edgesTex), SMAATexturePass2D(searchTex), offset[1].zw, offset[2].w);
-        d.y = coords.z;
+        float dy = coords.z;
 
         // We want the distances to be in pixel units:
-        d = abs(round(mad(SMAA_RT_METRICS.ww, d, -pixcoord.yy)));
+        dx = abs(round(mad(SMAA_RT_METRICS.w, dx, -pixcoord.y)));
+        dy = abs(round(mad(SMAA_RT_METRICS.w, dy, -pixcoord.y)));
 
         // SMAAArea below needs a sqrt, as the areas texture is compressed 
         // quadratically:
-        float2 sqrt_d = sqrt(d);
+        float sqrt_d_x = sqrt(dx);
+        float sqrt_d_y = sqrt(dy);
 
         // Fetch the bottom crossing edges:
         float e2 = SMAASampleLevelZeroOffset(edgesTex, coords.xz, int2(0, 1)).g;
 
         // Get the area for this direction:
-        weights.ba = SMAAArea(SMAATexturePass2D(areaTex), sqrt_d, e1, e2, subsampleIndices.x);
+        weights.ba = SMAAArea(SMAATexturePass2D(areaTex), float2(sqrt_d_x, sqrt_d_y), e1, e2, subsampleIndices.x);
 
         // Fix corners:
         coords.x = texcoord.x;
-        SMAADetectVerticalCornerPattern(SMAATexturePass2D(edgesTex), weights.ba, coords.xyxz, d);
+        SMAADetectVerticalCornerPattern(SMAATexturePass2D(edgesTex), weights.ba, coords.xyxz, float2(dx, dy));
     }
 
     return weights;

From 90845313fbce4bde019ed3fe1f69696f5e30962d Mon Sep 17 00:00:00 2001
From: Ken Pruiksma <pruiksma@amazon.com>
Date: Wed, 18 Aug 2021 16:59:34 -0500
Subject: [PATCH 25/37] Overhaul of LookModification (#3282)

* Fixed log2 shaper equations. Added bspline sampling for lut. Added options for custom log2 or linear lut with custom exposure ranges.

Signed-off-by: Ken Pruiksma <pruiksma@amazon.com>

* Added support for PQ shaper. Added shader option & cvar for lut sampling quality. Fixed issues in the blend lut shader that were causing considerable quality loss. No longer always changing to the log2 1000 nit shaper when blending luts - if the source luts all use the same shaper, keep using that shaper in the blended lut.

Signed-off-by: Ken Pruiksma <pruiksma@amazon.com>

* Fixed an integer -> float

Signed-off-by: Ken Pruiksma <pruiksma@amazon.com>

* Minor PR reveiw updates

Signed-off-by: Ken Pruiksma <pruiksma@amazon.com>
---
 .../Atom/Features/PostProcessing/Aces.azsli   |   5 +-
 .../Features/PostProcessing/Shapers.azsli     |  52 ++
 .../ApplyShaperLookupTable.azsl               |  30 +-
 .../PostProcessing/BlendColorGradingLuts.azsl |  45 +-
 .../LookModificationTransform.azsl            | 136 +++-
 ...ookModificationTransform.shadervariantlist |  12 +-
 .../Common/Code/3rdParty/ACES/ACES/Aces.cpp   |  44 +-
 .../Common/Code/3rdParty/ACES/ACES/Aces.h     |  22 +-
 .../ACES/AcesDisplayMapperFeatureProcessor.h  |   4 +-
 .../LookModificationParams.inl                |   8 +-
 .../AcesDisplayMapperFeatureProcessor.cpp     | 705 +++++++++---------
 .../AcesOutputTransformLutPass.cpp            |   4 +-
 .../ApplyShaperLookupTablePass.cpp            |   6 +-
 .../BakeAcesOutputTransformLutPass.cpp        |   4 +-
 .../LookModificationSettings.cpp              |   8 +
 .../LookModificationSettings.h                |   5 +-
 .../BlendColorGradingLutsPass.cpp             | 296 +++++---
 .../BlendColorGradingLutsPass.h               |   4 +-
 .../LookModificationCompositePass.cpp         |  73 +-
 .../LookModificationCompositePass.h           |  20 +-
 .../LookModificationTransformPass.cpp         |  41 +-
 .../Include/Atom/RPI.Public/Pass/ParentPass.h |  18 +
 .../LookModificationComponentConfig.h         |   5 +
 .../EditorLookModificationComponent.cpp       |  55 +-
 24 files changed, 945 insertions(+), 657 deletions(-)
 create mode 100644 Gems/Atom/Feature/Common/Assets/ShaderLib/Atom/Features/PostProcessing/Shapers.azsli

diff --git a/Gems/Atom/Feature/Common/Assets/ShaderLib/Atom/Features/PostProcessing/Aces.azsli b/Gems/Atom/Feature/Common/Assets/ShaderLib/Atom/Features/PostProcessing/Aces.azsli
index f81a8cdf37..b7a6c63dc2 100644
--- a/Gems/Atom/Feature/Common/Assets/ShaderLib/Atom/Features/PostProcessing/Aces.azsli
+++ b/Gems/Atom/Feature/Common/Assets/ShaderLib/Atom/Features/PostProcessing/Aces.azsli
@@ -75,6 +75,8 @@ UNDISCLOSED.
 ////////////////////////////////////////////////////////////////////////////////
 // Constants
 
+#pragma once
+
 #include <Atom/RPI/Math.azsli>
 
 static const float HALF_MAX = 65504.0f;
@@ -90,7 +92,8 @@ static const float DIM_SURROUND_GAMMA = 0.9811;
 enum class ShaperType
 {
     ShaperLinear,
-    ShaperLog2
+    ShaperLog2,
+    PqSmpteSt2084,
 };
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/Gems/Atom/Feature/Common/Assets/ShaderLib/Atom/Features/PostProcessing/Shapers.azsli b/Gems/Atom/Feature/Common/Assets/ShaderLib/Atom/Features/PostProcessing/Shapers.azsli
new file mode 100644
index 0000000000..a101867736
--- /dev/null
+++ b/Gems/Atom/Feature/Common/Assets/ShaderLib/Atom/Features/PostProcessing/Shapers.azsli
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <Atom/Features/PostProcessing/Aces.azsli>
+
+// Perceptual quantizer coefficients
+static const float PqM1 = 1305.0 / 8192.0;
+static const float PqM2 = 2533.0 / 32.0;
+static const float PqC1 = 102.0 / 128.0;
+static const float PqC2 = 2413.0 / 128.0;
+static const float PqC3 = 2392.0 / 128.0;
+static const float PqMaxNits = 10000.0;
+
+float3 ShaperToLinear(float3 shaperColor, ShaperType shaperType, float shaperBias, float shaperScale)
+{
+    // Apply the inverse of the shaper function to give the color in the working color space
+    switch (shaperType)
+    {
+        case ShaperType::ShaperLinear:
+            return (shaperColor - shaperBias) / shaperScale;
+        case ShaperType::ShaperLog2:
+            return pow(2.0, (shaperColor - shaperBias) / shaperScale);
+        case ShaperType::PqSmpteSt2084:
+            shaperColor = min(shaperColor, 1.0);
+            return PqMaxNits * pow(max(pow(shaperColor, 1.0 / PqM2) - PqC1, 0.0) / (PqC2 - PqC3 * pow(shaperColor, 1.0 / PqM2)), 1.0 / PqM1);
+    }
+    return shaperColor;
+}
+
+float3 LinearToShaper(float3 linearColor, ShaperType shaperType, float shaperBias, float shaperScale)
+{
+    // Convert from working color space to lut coordinates by applying the shaper function
+    switch (shaperType)
+    {
+        case ShaperType::ShaperLinear:
+            return linearColor * shaperScale + shaperBias;
+        case ShaperType::ShaperLog2:
+            return log2(linearColor) * shaperScale + shaperBias;
+        case ShaperType::PqSmpteSt2084:
+            linearColor = min(linearColor, PqMaxNits);
+            linearColor = linearColor / PqMaxNits;
+            return pow((PqC1 + PqC2 * pow(linearColor, PqM1)) / (1.0 + PqC3 * pow(linearColor, PqM1)), PqM2);
+    }
+    return linearColor;
+}
diff --git a/Gems/Atom/Feature/Common/Assets/Shaders/PostProcessing/ApplyShaperLookupTable.azsl b/Gems/Atom/Feature/Common/Assets/Shaders/PostProcessing/ApplyShaperLookupTable.azsl
index a180b09630..10d2eb1179 100644
--- a/Gems/Atom/Feature/Common/Assets/Shaders/PostProcessing/ApplyShaperLookupTable.azsl
+++ b/Gems/Atom/Feature/Common/Assets/Shaders/PostProcessing/ApplyShaperLookupTable.azsl
@@ -11,9 +11,7 @@
 #include <Atom/Features/PostProcessing/FullscreenPixelInfo.azsli>
 #include <Atom/Features/PostProcessing/FullscreenVertex.azsli>
 #include <Atom/Features/PostProcessing/PostProcessUtil.azsli>
-
-static const int SHAPER_LINEAR = 0;
-static const int SHAPER_LOG2 = 1;
+#include <Atom/Features/PostProcessing/Shapers.azsli>
 
 ShaderResourceGroup PassSrg : SRG_PerPass
 {
@@ -41,36 +39,22 @@ PSOutput MainPS(VSOutput IN)
     float2 uvCoord = float2(IN.m_texCoord.x, IN.m_texCoord.y);
     float3 color = PassSrg::m_colorTexture.Sample(PassSrg::LinearSampler, uvCoord).rgb;
 
+    ShaperType shaperType = (ShaperType)PassSrg::m_shaperType;
+
     // Convert from working color space to lut coordinates by applying the shaper function
-    float3 lutCoordinate = color;
-    if (PassSrg::m_shaperType == SHAPER_LINEAR)
-    {
-        lutCoordinate = color * PassSrg::m_shaperScale + PassSrg::m_shaperBias;
-    }
-    else if (PassSrg::m_shaperType == SHAPER_LOG2)
-    {
-        lutCoordinate = log2(color) * PassSrg::m_shaperScale + PassSrg::m_shaperBias;
-    }
+    float3 lutCoordinate = LinearToShaper(color, shaperType, PassSrg::m_shaperBias, PassSrg::m_shaperScale);
 
     // Adjust coordinate to the domain excluding the outer half texel in all directions
     uint3 outputDimensions;
     PassSrg::m_lut.GetDimensions(outputDimensions.x, outputDimensions.y, outputDimensions.z);
-    float3 coordBias = 1.0/(2.0 * outputDimensions);
-    float3 coordScale = (outputDimensions-1.0)/outputDimensions;
+    float3 coordBias = 1.0 / (2.0 * outputDimensions);
+    float3 coordScale = (outputDimensions - 1.0) / outputDimensions;
     lutCoordinate = (lutCoordinate * coordScale) + coordBias;
 
     float3 lutColor = PassSrg::m_lut.Sample(PassSrg::LinearSampler, lutCoordinate).rgb;
 
     // Apply the inverse of the shaper function to give the color in the working color space
-    float3 finalColor = lutColor;
-    if (PassSrg::m_shaperType == SHAPER_LINEAR)
-    {
-        finalColor = (lutColor - PassSrg::m_shaperBias)/PassSrg::m_shaperScale;
-    }
-    else if (PassSrg::m_shaperType == SHAPER_LOG2)
-    {
-        finalColor = pow(2.0, (lutColor - PassSrg::m_shaperBias)/PassSrg::m_shaperScale);
-    }
+    float3 finalColor = ShaperToLinear(lutColor, shaperType, PassSrg::m_shaperBias, PassSrg::m_shaperScale);
 
     OUT.m_color.rgb = finalColor;
     OUT.m_color.a = 1.0;
diff --git a/Gems/Atom/Feature/Common/Assets/Shaders/PostProcessing/BlendColorGradingLuts.azsl b/Gems/Atom/Feature/Common/Assets/Shaders/PostProcessing/BlendColorGradingLuts.azsl
index 6f97996c29..746e18cfc2 100644
--- a/Gems/Atom/Feature/Common/Assets/Shaders/PostProcessing/BlendColorGradingLuts.azsl
+++ b/Gems/Atom/Feature/Common/Assets/Shaders/PostProcessing/BlendColorGradingLuts.azsl
@@ -8,6 +8,7 @@
 
 #include <Atom/Features/SrgSemantics.azsli>
 #include <Atom/Features/PostProcessing/Aces.azsli>
+#include <Atom/Features/PostProcessing/Shapers.azsli>
 
 ShaderResourceGroup PassSrg : SRG_PerPass_WithFallback
 {
@@ -62,40 +63,18 @@ ShaderResourceGroup PassSrg : SRG_PerPass_WithFallback
 [[range(0, 4)]]
 option uint o_numSourceLuts = 0;
 
-float3 ShaperToLinear(float3 shaperColor, ShaperType shaperType, float shaperBias, float shaperScale)
-{
-    // Apply the inverse of the shaper function to give the color in the working color space
-    float3 linearColor = shaperColor;
-    if (shaperType == ShaperType::ShaperLinear)
-    {
-        linearColor = (shaperColor - shaperBias)/shaperScale;
-    }
-    else if (shaperType == ShaperType::ShaperLog2)
-    {
-        linearColor = pow(2.0, (shaperColor - shaperBias)/shaperScale);
-    }
-    return linearColor;
-}
-
-float3 LinearToShaper(float3 linearColor, ShaperType shaperType, float shaperBias, float shaperScale)
-{
-    // Convert from working color space to lut coordinates by applying the shaper function
-    float3 shaperColor = linearColor;
-    if (shaperType == ShaperType::ShaperLinear)
-    {
-        shaperColor = linearColor * shaperScale + shaperBias;
-    }
-    else if (shaperType == ShaperType::ShaperLog2)
-    {
-        shaperColor = log2(linearColor) * shaperScale + shaperBias;
-    }
-    return shaperColor;
-}
-
 float3 GetSourceLutLinearColor(float3 baseColor, Texture3D<float4> sourceLut, ShaperType shaperType, float shaperBias, float shaperScale)
 {
     // Convert from reference linearColor to the lutCoordinate for this Lut
     float3 lutCoord = LinearToShaper(baseColor, shaperType, shaperBias, shaperScale);
+
+    // Adjust coordinate to the domain excluding the outer half texel in all directions
+    uint3 outputDimensions;
+    sourceLut.GetDimensions(outputDimensions.x, outputDimensions.y, outputDimensions.z);
+    float3 coordBias = 1.0 / (2.0 * outputDimensions);
+    float3 coordScale = (outputDimensions - 1.0) / outputDimensions;
+    lutCoord = (lutCoord * coordScale) + coordBias;
+
     float3 lutColor = sourceLut.SampleLevel(PassSrg::LinearSampler, lutCoord, 0).rgb;
     // Convert to linear
     float3 linearColor = ShaperToLinear(lutColor, shaperType, shaperBias, shaperScale);
@@ -115,11 +94,7 @@ void MainCS(uint3 dispatch_id: SV_DispatchThreadID)
     }
 
     // Get coordinates within the blended LUT 3D texture
-    float3 baseCoord = float3 (
-        (float)(dispatch_id.x)/(float)PassSrg::m_blendedLutDimensions.x,
-        (float)(dispatch_id.y)/(float)PassSrg::m_blendedLutDimensions.y,
-        (float)(dispatch_id.z)/(float)PassSrg::m_blendedLutDimensions.z
-        );
+    float3 baseCoord = float3(outPixel) / float3(PassSrg::m_blendedLutDimensions - 1.0);
     
     // Convert to the base linear color (this is the color of the identity LUT)
     float3 baseColor = ShaperToLinear(baseCoord, (ShaperType)PassSrg::m_blendedLutShaperType, PassSrg::m_blendedLutShaperBias, PassSrg::m_blendedLutShaperScale);
diff --git a/Gems/Atom/Feature/Common/Assets/Shaders/PostProcessing/LookModificationTransform.azsl b/Gems/Atom/Feature/Common/Assets/Shaders/PostProcessing/LookModificationTransform.azsl
index 8b1841c5e1..4741b01617 100644
--- a/Gems/Atom/Feature/Common/Assets/Shaders/PostProcessing/LookModificationTransform.azsl
+++ b/Gems/Atom/Feature/Common/Assets/Shaders/PostProcessing/LookModificationTransform.azsl
@@ -12,6 +12,7 @@
 #include <Atom/Features/PostProcessing/FullscreenPixelInfo.azsli>
 #include <Atom/Features/PostProcessing/FullscreenVertex.azsli>
 #include <Atom/Features/PostProcessing/PostProcessUtil.azsli>
+#include <Atom/Features/PostProcessing/Shapers.azsli>
 #include "EyeAdaptationUtil.azsli"
 
 ShaderResourceGroup PassSrg : SRG_PerPass_WithFallback
@@ -42,12 +43,111 @@ option bool o_enableExposureControlFeature = false;
 // Option shader variable to enable color grading LUT.
 option bool o_enableColorGradingLut = false;
 
+// Controls the sampling quality of the blended LUT. Setting this higher can improve the quality of particularly tricky luts.
+// 0 - linear
+// 1 - 7 tap b-spline
+// 2 - 19 tap b-spline
+[[range(0, 2)]]
+option uint o_lutSampleQuality = 0;
+
+// Sample a 3dtexture with a 7 or 19 tap B-Spline. Consider ripping this out and putting in a more general location.
+// This function samples a 4x4x4 neighborhood around the uv. Normally this would take 64 samples, but by taking
+// advantage of bilinear filtering this can be done with 27 taps on the edges between pixels. The cost is further
+// reduced by dropping either the 8 corners (19 total taps) or also dropping the 12 edges (7 total taps).
+float4 SampleBSpline3D(Texture3D<float4> texture, SamplerState linearSampler, float3 uv, float3 textureSize, float3 rcpTextureSize)
+{
+    // Think of sample locations in the 4x4 neighborhood as having a top left coordinate of 0,0 and
+    // a bottom right coordinate of 3,3.
+
+    // Find the position in texture space then round it to get the center of the 1,1 pixel (tc1)
+    float3 texelPos = uv * textureSize;
+    float3 tc1= floor(texelPos - 0.5) + 0.5;
+
+    // Offset from center position to texel
+    float3 f = texelPos - tc1;
+
+    // Compute B-Spline weights based on the offset
+    float3 OneMinusF = (1.0 - f);
+    float3 OneMinusF2 = OneMinusF * OneMinusF;
+    float3 OneMinusF3 = OneMinusF2 * OneMinusF;
+    float3 w0 = OneMinusF3;
+    float3 w1 = 4.0 + 3.0 * f * f * f - 6.0 * f * f;
+    float3 w2 = 4.0 + 3.0 * OneMinusF3 - 6.0 * OneMinusF2;
+    float3 w3 = f * f * f;
+
+    float3 w12 = w1 + w2;
+
+    // Compute uv coordinates for sampling the texture
+    float3 tc0 = (tc1 - 1.0f) * rcpTextureSize;
+    float3 tc3 = (tc1 + 2.0f) * rcpTextureSize;
+    float3 tc12 = (tc1 + w2 / w12) * rcpTextureSize;
+
+    // Compute sample weights
+    float sw0 = w12.x * w0.y * w12.z;
+    float sw1 = w0.x  * w12.y * w12.z;
+    float sw2 = w12.x * w12.y * w12.z;
+    float sw3 = w3.x  * w12.y * w12.z;
+    float sw4 = w12.x * w3.y * w12.z;
+    float sw5 = w12.x * w12.y * w0.z;
+    float sw6 = w12.x * w12.y * w3.z;
+
+    // total weight of samples to normalize result.
+    float totalWeight = sw0 + sw1 + sw2 + sw3 + sw4 + sw5 + sw6;
+
+    float4 result = 0.0f;
+    result += texture.SampleLevel(linearSampler, float3(tc12.x,  tc0.y, tc12.z), 0.0) * sw0;
+    result += texture.SampleLevel(linearSampler, float3( tc0.x, tc12.y, tc12.z), 0.0) * sw1;
+    result += texture.SampleLevel(linearSampler, float3(tc12.x, tc12.y, tc12.z), 0.0) * sw2;
+    result += texture.SampleLevel(linearSampler, float3( tc3.x, tc12.y, tc12.z), 0.0) * sw3;
+    result += texture.SampleLevel(linearSampler, float3(tc12.x,  tc3.y, tc12.z), 0.0) * sw4;
+    result += texture.SampleLevel(linearSampler, float3(tc12.x,  tc12.y, tc0.z), 0.0) * sw5;
+    result += texture.SampleLevel(linearSampler, float3(tc12.x,  tc12.y, tc3.z), 0.0) * sw6;
+
+    if (o_lutSampleQuality == 2)
+    {
+        // Extra 12 taps for Diagonals to increase the quality further.
+
+        float sw7 = w0.x * w0.y * w12.z;
+        float sw8 = w0.x * w3.y * w12.z;
+        float sw9 = w3.x * w0.y * w12.z;
+        float sw10 = w3.x * w3.y * w12.z;
+
+        float sw11 = w12.x * w0.y * w0.z;
+        float sw12 = w12.x * w0.y * w3.z;
+        float sw13 = w12.x * w3.y * w0.z;
+        float sw14 = w12.x * w3.y * w3.z;
+
+        float sw15 = w0.x * w12.y * w0.z;
+        float sw16 = w0.x * w12.y * w3.z;
+        float sw17 = w3.x * w12.y * w0.z;
+        float sw18 = w3.x * w12.y * w3.z;
+
+        totalWeight += sw7 + sw8 + sw9 + sw10 + sw11 + sw12 + sw13 + sw14 + sw15 + sw16 + sw17 + sw18;
+
+        result += texture.SampleLevel(linearSampler, float3(tc0.x, tc0.y, tc12.z), 0.0) * sw7;
+        result += texture.SampleLevel(linearSampler, float3(tc0.x, tc3.y, tc12.z), 0.0) * sw8;
+        result += texture.SampleLevel(linearSampler, float3(tc3.x, tc0.y, tc12.z), 0.0) * sw9;
+        result += texture.SampleLevel(linearSampler, float3(tc3.x, tc3.y, tc12.z), 0.0) * sw10;
+
+        result += texture.SampleLevel(linearSampler, float3(tc12.x, tc0.y, tc0.z), 0.0) * sw11;
+        result += texture.SampleLevel(linearSampler, float3(tc12.x, tc0.y, tc3.z), 0.0) * sw12;
+        result += texture.SampleLevel(linearSampler, float3(tc12.x, tc3.y, tc0.z), 0.0) * sw13;
+        result += texture.SampleLevel(linearSampler, float3(tc12.x, tc3.y, tc3.z), 0.0) * sw14;
+
+        result += texture.SampleLevel(linearSampler, float3(tc0.x,  tc12.y, tc0.z), 0.0) * sw15;
+        result += texture.SampleLevel(linearSampler, float3(tc0.x,  tc12.y, tc3.z), 0.0) * sw16;
+        result += texture.SampleLevel(linearSampler, float3(tc3.x,  tc12.y, tc0.z), 0.0) * sw17;
+        result += texture.SampleLevel(linearSampler, float3(tc3.x,  tc12.y, tc3.z), 0.0) * sw18;
+    }
+    return result / totalWeight;
+}
+
 PSOutput MainPS(VSOutput IN)
 {
     PSOutput OUT;
 
     // Fetch the pixel color from the input texture
-    float3 color = PassSrg::m_framebuffer.Sample(PassSrg::LinearSampler, IN.m_texCoord).rgb;
+    float3 color = PassSrg::m_framebuffer.SampleLevel(PassSrg::LinearSampler, IN.m_texCoord, 0.0).rgb;
 
     if (o_enableExposureControlFeature)
     {
@@ -63,36 +163,28 @@ PSOutput MainPS(VSOutput IN)
     if (o_enableColorGradingLut)
     {
         // Convert from working color space to lut coordinates by applying the shaper function
-        float3 lutCoordinate = color;
-        if (shaperType == ShaperType::ShaperLinear)
-        {
-            lutCoordinate = color * PassSrg::m_shaperScale + PassSrg::m_shaperBias;
-        }
-        else if (shaperType == ShaperType::ShaperLog2)
-        {
-            lutCoordinate = log2(color) * PassSrg::m_shaperScale + PassSrg::m_shaperBias;
-        }
+        float3 lutCoordinate = LinearToShaper(color, shaperType, PassSrg::m_shaperBias, PassSrg::m_shaperScale);
 
         // Adjust coordinate to the domain excluding the outer half texel in all directions
         uint3 outputDimensions;
         PassSrg::m_gradingLut.GetDimensions(outputDimensions.x, outputDimensions.y, outputDimensions.z);
         float3 coordBias = 0.5f / outputDimensions;
-        float3 coordScale = (outputDimensions-1.0)/outputDimensions;
+        float3 sizeMinusOne = outputDimensions - 1.0;
+        float3 coordScale = sizeMinusOne / outputDimensions;
         lutCoordinate = (lutCoordinate * coordScale) + coordBias;
 
-        float3 lutColor = PassSrg::m_gradingLut.Sample(PassSrg::LinearSampler, lutCoordinate).rgb;
+        float3 lutColor = float3(0.0, 0.0, 0.0);
+        if (o_lutSampleQuality == 0)
+        {
+            lutColor = PassSrg::m_gradingLut.SampleLevel(PassSrg::LinearSampler, lutCoordinate, 0.0).rgb;
+        }
+        else
+        {
+            lutColor = SampleBSpline3D(PassSrg::m_gradingLut, PassSrg::LinearSampler, lutCoordinate, float3(outputDimensions), 1.0 / float3(outputDimensions)).rgb;
+        }
 
         // Apply the inverse of the shaper function to give the color in the working color space
-        float3 finalColor = lutColor;
-        if (shaperType == ShaperType::ShaperLinear)
-        {
-            finalColor = (lutColor - PassSrg::m_shaperBias)/PassSrg::m_shaperScale;
-        }
-        else if (shaperType == ShaperType::ShaperLog2)
-        {
-            finalColor = pow(2.0, (lutColor - PassSrg::m_shaperBias)/PassSrg::m_shaperScale);
-        }
-        color = finalColor;
+        color = ShaperToLinear(lutColor, shaperType, PassSrg::m_shaperBias, PassSrg::m_shaperScale);
     }
 
     OUT.m_color.rgb = color;
diff --git a/Gems/Atom/Feature/Common/Assets/Shaders/PostProcessing/LookModificationTransform.shadervariantlist b/Gems/Atom/Feature/Common/Assets/Shaders/PostProcessing/LookModificationTransform.shadervariantlist
index 0de004bde6..88d6bf9b4e 100644
--- a/Gems/Atom/Feature/Common/Assets/Shaders/PostProcessing/LookModificationTransform.shadervariantlist
+++ b/Gems/Atom/Feature/Common/Assets/Shaders/PostProcessing/LookModificationTransform.shadervariantlist
@@ -1,9 +1,13 @@
 { 
     "Shader" : "LookModificationTransform.shader",
     "Variants" : [ 
-        {   "StableId": 1, "Options" : { "o_enableExposureControlFeature": "true", "o_enableColorGradingLut": "true" } },
-        {   "StableId": 2, "Options" : { "o_enableExposureControlFeature": "true", "o_enableColorGradingLut": "false" } },
-        {   "StableId": 3, "Options" : { "o_enableExposureControlFeature": "false", "o_enableColorGradingLut": "true" } },
-        {   "StableId": 4, "Options" : { "o_enableExposureControlFeature": "false", "o_enableColorGradingLut": "false" } }
+        {   "StableId": 1, "Options" : { "o_enableExposureControlFeature": "true", "o_enableColorGradingLut": "false" } },
+        {   "StableId": 2, "Options" : { "o_enableExposureControlFeature": "false", "o_enableColorGradingLut": "false" } },
+        {   "StableId": 3, "Options" : { "o_enableExposureControlFeature": "true", "o_enableColorGradingLut": "true", "o_lutSampleQuality": 0 } },
+        {   "StableId": 4, "Options" : { "o_enableExposureControlFeature": "false", "o_enableColorGradingLut": "true", "o_lutSampleQuality": 0 } },
+        {   "StableId": 5, "Options" : { "o_enableExposureControlFeature": "true", "o_enableColorGradingLut": "true", "o_lutSampleQuality": 1 } },
+        {   "StableId": 6, "Options" : { "o_enableExposureControlFeature": "false", "o_enableColorGradingLut": "true", "o_lutSampleQuality": 1 } },
+        {   "StableId": 7, "Options" : { "o_enableExposureControlFeature": "true", "o_enableColorGradingLut": "true", "o_lutSampleQuality": 2 } },
+        {   "StableId": 8, "Options" : { "o_enableExposureControlFeature": "false", "o_enableColorGradingLut": "true", "o_lutSampleQuality": 2 } }
     ]    
 }
diff --git a/Gems/Atom/Feature/Common/Code/3rdParty/ACES/ACES/Aces.cpp b/Gems/Atom/Feature/Common/Code/3rdParty/ACES/ACES/Aces.cpp
index 125614235f..79f16ee628 100644
--- a/Gems/Atom/Feature/Common/Code/3rdParty/ACES/ACES/Aces.cpp
+++ b/Gems/Atom/Feature/Common/Code/3rdParty/ACES/ACES/Aces.cpp
@@ -203,47 +203,37 @@ namespace AZ
             return ODT_48nits;
         }
 
+        ShaperParams GetLog2ShaperParameters(float minStops, float maxStops)
+        {
+            ShaperParams shaperParams;
+
+            constexpr float Log2MediumGray = -2.47393118833f; // log2f(0.18f);
+            shaperParams.m_type = ShaperType::Log2;
+            shaperParams.m_scale = 1.0f / (maxStops - minStops);
+            shaperParams.m_bias = -((minStops + Log2MediumGray) * shaperParams.m_scale);
+
+            return shaperParams;
+        }
+
         ShaperParams GetAcesShaperParameters(OutputDeviceTransformType odtType)
         {
             AZ_Assert(static_cast<uint32_t>(odtType) < static_cast<uint32_t>(NumOutputDeviceTransformTypes), "Invalid ODT type specified.");
 
-            ShaperParams shaperParams;
-
-            // These values represent and low and high end of the dynamic range in terms of stops from middle grey (0.18)
-            float lowerDynamicRangeInStops;
-            float higherDynamicRangeInStops;
-            const float MIDDLE_GREY = 0.18f;
-
             switch (odtType)
             {
             case OutputDeviceTransformType_48Nits:
-                lowerDynamicRangeInStops = -6.5f;
-                higherDynamicRangeInStops = 6.5f;
-                break;
+                return GetLog2ShaperParameters(-6.5f, 6.5f);
             case OutputDeviceTransformType_1000Nits:
-                lowerDynamicRangeInStops = -12.f;
-                higherDynamicRangeInStops = 10.f;
-                break;
+                return GetLog2ShaperParameters(-12.0f, 10.0f);
             case OutputDeviceTransformType_2000Nits:
-                lowerDynamicRangeInStops = -12.f;
-                higherDynamicRangeInStops = 11.f;
-                break;
+                return GetLog2ShaperParameters(-12.0f, 11.0f);
             case OutputDeviceTransformType_4000Nits:
-                lowerDynamicRangeInStops = -12.f;
-                higherDynamicRangeInStops = 12.f;
-                break;
+                return GetLog2ShaperParameters(-12.0f, 12.0f);
             default:
                 AZ_Assert(false, "Invalid output device transform type.");
-                return shaperParams;
                 break;
             }
-
-            float logMin = log2(MIDDLE_GREY * exp2(lowerDynamicRangeInStops));
-            float logMax = log2(MIDDLE_GREY * exp2(higherDynamicRangeInStops));
-            shaperParams.scale = 1.0f / (logMax - logMin);
-            shaperParams.bias = -shaperParams.scale * logMin;
-            shaperParams.type = ShaperType::Log2;
-            return shaperParams;
+            return ShaperParams();
         }
 
         Matrix3x3 GetColorConvertionMatrix(ColorConvertionMatrixType type)
diff --git a/Gems/Atom/Feature/Common/Code/3rdParty/ACES/ACES/Aces.h b/Gems/Atom/Feature/Common/Code/3rdParty/ACES/ACES/Aces.h
index 94d6434b93..3ec2885a99 100644
--- a/Gems/Atom/Feature/Common/Code/3rdParty/ACES/ACES/Aces.h
+++ b/Gems/Atom/Feature/Common/Code/3rdParty/ACES/ACES/Aces.h
@@ -124,18 +124,19 @@ namespace AZ
             NumColorConvertionMatrixTypes
         };
 
-        enum ShaperType
+        enum class ShaperType  : uint32_t
         {
             Linear = 0,
             Log2 = 1,
+            PqSmpteSt2084 = 2,
             NumShaperTypes
         };
 
         struct ShaperParams
         {
-            ShaperType type = ShaperType::Linear;
-            float bias = 0.f;
-            float scale = 1.f;
+            ShaperType m_type = ShaperType::Linear;
+            float m_bias = 0.0f;
+            float m_scale = 1.0f;
         };
 
         enum class DisplayMapperOperationType : uint32_t
@@ -151,10 +152,14 @@ namespace AZ
         enum class ShaperPresetType
         {
             None = 0,
-            Log2_48_nits,
-            Log2_1000_nits,
-            Log2_2000_nits,
-            Log2_4000_nits
+            LinearCustomRange,
+            Log2_48Nits,
+            Log2_1000Nits,
+            Log2_2000Nits,
+            Log2_4000Nits,
+            Log2CustomRange,
+            PqSmpteSt2084,
+            NumShaperTypes
         };
 
         enum class ToneMapperType
@@ -171,6 +176,7 @@ namespace AZ
         };
 
         SegmentedSplineParamsC9 GetAcesODTParameters(OutputDeviceTransformType odtType);
+        ShaperParams GetLog2ShaperParameters(float minStops, float maxStops);
         ShaperParams GetAcesShaperParameters(OutputDeviceTransformType odtType);
         Matrix3x3 GetColorConvertionMatrix(ColorConvertionMatrixType type);
 
diff --git a/Gems/Atom/Feature/Common/Code/Include/Atom/Feature/ACES/AcesDisplayMapperFeatureProcessor.h b/Gems/Atom/Feature/Common/Code/Include/Atom/Feature/ACES/AcesDisplayMapperFeatureProcessor.h
index 7d2aa18f29..6be81c8cae 100644
--- a/Gems/Atom/Feature/Common/Code/Include/Atom/Feature/ACES/AcesDisplayMapperFeatureProcessor.h
+++ b/Gems/Atom/Feature/Common/Code/Include/Atom/Feature/ACES/AcesDisplayMapperFeatureProcessor.h
@@ -78,7 +78,7 @@ namespace AZ
 
             static OutputDeviceTransformType GetOutputDeviceTransformType(RHI::Format bufferFormat);
             static void GetAcesDisplayMapperParameters(DisplayMapperParameters* displayMapperParameters, OutputDeviceTransformType odtType);
-            static ShaperParams GetShaperParameters(ShaperPresetType shaperPreset);
+            static ShaperParams GetShaperParameters(ShaperPresetType shaperPreset, float customMinEv = 0.0f, float customMaxEv = 0.0f);
             static void GetDefaultDisplayMapperConfiguration(DisplayMapperConfigurationDescriptor& config);
 
             // DisplayMapperFeatureProcessorInteface overrides...
@@ -102,8 +102,6 @@ namespace AZ
 
             static constexpr const char* FeatureProcessorName = "AcesDisplayMapperFeatureProcessor";
 
-            static const int LutSize = 32;
-            static const RHI::Format LutFormat = RHI::Format::R16G16B16A16_FLOAT;
             static const int ImagePoolBudget = 1 << 20; // 1 Megabyte
 
             // LUTs that are baked through shaders
diff --git a/Gems/Atom/Feature/Common/Code/Include/Atom/Feature/PostProcess/LookModification/LookModificationParams.inl b/Gems/Atom/Feature/Common/Code/Include/Atom/Feature/PostProcess/LookModification/LookModificationParams.inl
index 38a1987caa..4c3cf8ac92 100644
--- a/Gems/Atom/Feature/Common/Code/Include/Atom/Feature/PostProcess/LookModification/LookModificationParams.inl
+++ b/Gems/Atom/Feature/Common/Code/Include/Atom/Feature/PostProcess/LookModification/LookModificationParams.inl
@@ -10,11 +10,9 @@
 // PARAM(NAME, MEMBER_NAME, DEFAULT_VALUE, ...)
 
 AZ_GFX_BOOL_PARAM(Enabled, m_enabled, false)
-
 AZ_GFX_COMMON_PARAM(Data::Asset<RPI::AnyAsset>, ColorGradingLut, m_colorGradingLut, {})
-
-AZ_GFX_COMMON_PARAM(AZ::Render::ShaperPresetType, ShaperPresetType, m_shaperPresetType, AZ::Render::ShaperPresetType::Log2_48_nits)
-
+AZ_GFX_COMMON_PARAM(AZ::Render::ShaperPresetType, ShaperPresetType, m_shaperPresetType, AZ::Render::ShaperPresetType::Log2_48Nits)
+AZ_GFX_COMMON_PARAM(float, CustomMinExposure, m_customMinExposure, -6.5)
+AZ_GFX_COMMON_PARAM(float, CustomMaxExposure, m_customMaxExposure, 6.5)
 AZ_GFX_FLOAT_PARAM(ColorGradingLutIntensity, m_colorGradingLutIntensity, 1.0)
-
 AZ_GFX_FLOAT_PARAM(ColorGradingLutOverride, m_colorGradingLutOverride, 1.0)
diff --git a/Gems/Atom/Feature/Common/Code/Source/ACES/AcesDisplayMapperFeatureProcessor.cpp b/Gems/Atom/Feature/Common/Code/Source/ACES/AcesDisplayMapperFeatureProcessor.cpp
index 4c057aab2a..c6c41edb31 100644
--- a/Gems/Atom/Feature/Common/Code/Source/ACES/AcesDisplayMapperFeatureProcessor.cpp
+++ b/Gems/Atom/Feature/Common/Code/Source/ACES/AcesDisplayMapperFeatureProcessor.cpp
@@ -21,6 +21,7 @@
 
 namespace
 {
+    static const AZ::RHI::Format LutFormat = AZ::RHI::Format::R16G16B16A16_FLOAT;
 
     uint16_t ConvertFloatToHalf(const float Value)
     {
@@ -56,395 +57,409 @@ namespace
     }
 }
 
-namespace AZ
+namespace AZ::Render
 {
-    namespace Render
+    void AcesDisplayMapperFeatureProcessor::Reflect(ReflectContext* context)
     {
-        void AcesDisplayMapperFeatureProcessor::Reflect(ReflectContext* context)
+        if (auto* serializeContext = azrtti_cast<SerializeContext*>(context))
         {
-            if (auto* serializeContext = azrtti_cast<SerializeContext*>(context))
-            {
-                serializeContext
-                    ->Class<AcesDisplayMapperFeatureProcessor, FeatureProcessor>()
-                    ->Version(0);
-            }
+            serializeContext
+                ->Class<AcesDisplayMapperFeatureProcessor, FeatureProcessor>()
+                ->Version(0);
+        }
+    }
+
+    void AcesDisplayMapperFeatureProcessor::Activate()
+    {
+        GetDefaultDisplayMapperConfiguration(m_displayMapperConfiguration);
+    }
+
+    void AcesDisplayMapperFeatureProcessor::Deactivate()
+    {
+        m_ownedLuts.clear();
+    }
+
+    void AcesDisplayMapperFeatureProcessor::Simulate(const FeatureProcessor::SimulatePacket& packet)
+    {
+        AZ_TRACE_METHOD();
+        AZ_UNUSED(packet);
+    }
+
+    void AcesDisplayMapperFeatureProcessor::Render([[maybe_unused]] const FeatureProcessor::RenderPacket& packet)
+    {
+    }
+
+    void AcesDisplayMapperFeatureProcessor::ApplyLdrOdtParameters(DisplayMapperParameters* displayMapperParameters)
+    {
+        AZ_Assert(displayMapperParameters != nullptr, "The pOutParameters must not to be null pointer.");
+        if (displayMapperParameters == nullptr)
+        {
+            return;
         }
 
-        void AcesDisplayMapperFeatureProcessor::Activate()
+        // These values in the ODT parameter are taken from the reference ACES transform. 
+        //  
+        // The original ACES references.
+        // Common:
+        // https://github.com/ampas/aces-dev/blob/master/transforms/ctl/lib/ACESlib.ODT_Common.ctl
+        // For sRGB:
+        // https://github.com/ampas/aces-dev/tree/master/transforms/ctl/odt/sRGB
+        displayMapperParameters->m_cinemaLimits[0] = 0.02f;
+        displayMapperParameters->m_cinemaLimits[1] = 48.0f;
+        displayMapperParameters->m_acesSplineParams = GetAcesODTParameters(OutputDeviceTransformType_48Nits);
+        displayMapperParameters->m_OutputDisplayTransformFlags = AlterSurround | ApplyDesaturation | ApplyCATD60toD65;
+        displayMapperParameters->m_OutputDisplayTransformMode = Srgb;
+        ColorConvertionMatrixType   colorMatrixType = XYZ_To_Rec709;
+        switch (displayMapperParameters->m_OutputDisplayTransformMode)
         {
-            GetDefaultDisplayMapperConfiguration(m_displayMapperConfiguration);
+        case Srgb:
+            colorMatrixType = XYZ_To_Rec709;
+            break;
+        case PerceptualQuantizer:
+        case Ldr:
+            colorMatrixType = XYZ_To_Bt2020;
+            break;
+        default:
+            break;
+        }
+        displayMapperParameters->m_XYZtoDisplayPrimaries = GetColorConvertionMatrix(colorMatrixType);
+
+        displayMapperParameters->m_surroundGamma = 0.9811f;
+        displayMapperParameters->m_gamma = 2.2f;
+    }
+
+    void AcesDisplayMapperFeatureProcessor::ApplyHdrOdtParameters(DisplayMapperParameters* displayMapperParameters, const OutputDeviceTransformType& odtType)
+    {
+        AZ_Assert(displayMapperParameters != nullptr, "The pOutParameters must not to be null pointer.");
+        if (displayMapperParameters == nullptr)
+        {
+            return;
         }
 
-        void AcesDisplayMapperFeatureProcessor::Deactivate()
+        // Dynamic range limit values taken from NVIDIA HDR sample. 
+        // These values represent and low and high end of the dynamic range in terms of stops from middle grey (0.18)
+        float lowerDynamicRangeInStops = -12.f;
+        float higherDynamicRangeInStops = 10.f;
+        const float MIDDLE_GREY = 0.18f;
+
+        switch (odtType)
         {
-            m_ownedLuts.clear();
+        case OutputDeviceTransformType_1000Nits:
+            higherDynamicRangeInStops = 10.f;
+            break;
+        case OutputDeviceTransformType_2000Nits:
+            higherDynamicRangeInStops = 11.f;
+            break;
+        case OutputDeviceTransformType_4000Nits:
+            higherDynamicRangeInStops = 12.f;
+            break;
+        default:
+            AZ_Assert(false, "Invalid output device transform type.");
+            break;
         }
 
-        void AcesDisplayMapperFeatureProcessor::Simulate(const FeatureProcessor::SimulatePacket& packet)
+        displayMapperParameters->m_cinemaLimits[0] = MIDDLE_GREY * exp2(lowerDynamicRangeInStops);
+        displayMapperParameters->m_cinemaLimits[1] = MIDDLE_GREY * exp2(higherDynamicRangeInStops);
+        displayMapperParameters->m_acesSplineParams = GetAcesODTParameters(odtType);
+        displayMapperParameters->m_OutputDisplayTransformFlags = AlterSurround | ApplyDesaturation | ApplyCATD60toD65;
+        displayMapperParameters->m_OutputDisplayTransformMode = PerceptualQuantizer;
+        ColorConvertionMatrixType   colorMatrixType = XYZ_To_Bt2020;
+        displayMapperParameters->m_XYZtoDisplayPrimaries = GetColorConvertionMatrix(colorMatrixType);
+
+        // Surround gamma value is from the dim surround gamma from the ACES reference transforms.
+        // https://github.com/ampas/aces-dev/blob/master/transforms/ctl/lib/ACESlib.ODT_Common.ctl
+        displayMapperParameters->m_surroundGamma = 0.9811f;
+        displayMapperParameters->m_gamma = 1.0f; // gamma not used with perceptual quantizer, but just set to 1.0 anyways
+    }
+
+    OutputDeviceTransformType AcesDisplayMapperFeatureProcessor::GetOutputDeviceTransformType(RHI::Format bufferFormat)
+    {
+        OutputDeviceTransformType outputDeviceTransformType = OutputDeviceTransformType_48Nits;
+        if (bufferFormat == RHI::Format::R8G8B8A8_UNORM ||
+            bufferFormat == RHI::Format::B8G8R8A8_UNORM)
         {
-            AZ_TRACE_METHOD();
-            AZ_UNUSED(packet);
+            outputDeviceTransformType = OutputDeviceTransformType_48Nits;
+        }
+        else if (bufferFormat == RHI::Format::R10G10B10A2_UNORM)
+        {
+            outputDeviceTransformType = OutputDeviceTransformType_1000Nits;
+        }
+        else
+        {
+            AZ_Assert(false, "Not yet supported.");
+            // To work normally on unsupported environment, initialize the display parameters by OutputDeviceTransformType_48Nits.
+            outputDeviceTransformType = OutputDeviceTransformType_48Nits;
+        }
+        return outputDeviceTransformType;
+    }
+
+    void AcesDisplayMapperFeatureProcessor::GetAcesDisplayMapperParameters(DisplayMapperParameters* displayMapperParameters, OutputDeviceTransformType odtType)
+    {
+        switch (odtType)
+        {
+        case OutputDeviceTransformType_48Nits:
+            ApplyLdrOdtParameters(displayMapperParameters);
+            break;
+        case OutputDeviceTransformType_1000Nits:
+        case OutputDeviceTransformType_2000Nits:
+        case OutputDeviceTransformType_4000Nits:
+            ApplyHdrOdtParameters(displayMapperParameters, odtType);
+            break;
+        default:
+            AZ_Assert(false, "This ODT type[%d] is not supported.", odtType);
+            break;
+        }
+    }
+
+    void AcesDisplayMapperFeatureProcessor::GetOwnedLut(DisplayMapperLut& displayMapperLut, const AZ::Name& lutName)
+    {
+        auto it = m_ownedLuts.find(lutName);
+        if (it == m_ownedLuts.end())
+        {
+            InitializeLutImage(lutName);
+            it = m_ownedLuts.find(lutName);
+            AZ_Assert(it != m_ownedLuts.end(), "AcesDisplayMapperFeatureProcessor unable to create LUT %s", lutName.GetCStr());
+        }
+        displayMapperLut = it->second;
+    }
+
+    void AcesDisplayMapperFeatureProcessor::GetDisplayMapperLut(DisplayMapperLut& displayMapperLut)
+    {
+        const AZ::Name acesLutName("AcesLutImage");
+        auto it = m_ownedLuts.find(acesLutName);
+        if (it == m_ownedLuts.end())
+        {
+            InitializeLutImage(acesLutName);
+
+            it = m_ownedLuts.find(acesLutName);
+            AZ_Assert(it != m_ownedLuts.end(), "AcesDisplayMapperFeatureProcessor unable to create ACES LUT image");
+        }
+        displayMapperLut = it->second;
+    }
+
+    void AcesDisplayMapperFeatureProcessor::GetLutFromAssetLocation(DisplayMapperAssetLut& displayMapperAssetLut, const AZStd::string& assetPath)
+    {
+        Data::AssetId assetId = RPI::AssetUtils::GetAssetIdForProductPath(assetPath.c_str(), RPI::AssetUtils::TraceLevel::Error);
+        GetLutFromAssetId(displayMapperAssetLut, assetId);
+    }
+
+    void AcesDisplayMapperFeatureProcessor::GetLutFromAssetId(DisplayMapperAssetLut& displayMapperAssetLut, const AZ::Data::AssetId assetId)
+    {
+        if (!assetId.IsValid())
+        {
+            return;
         }
 
-        void AcesDisplayMapperFeatureProcessor::Render([[maybe_unused]] const FeatureProcessor::RenderPacket& packet)
+        // Check first if this already exists
+        auto it = m_assetLuts.find(assetId.ToString<AZStd::string>());
+        if (it != m_assetLuts.end())
         {
+            displayMapperAssetLut = it->second;
+            return;
         }
 
-        void AcesDisplayMapperFeatureProcessor::ApplyLdrOdtParameters(DisplayMapperParameters* displayMapperParameters)
+        // Read the lut which is a .3dl file embedded within an azasset file.
+        Data::Asset<RPI::AnyAsset> asset = RPI::AssetUtils::LoadAssetById<RPI::AnyAsset>(assetId, RPI::AssetUtils::TraceLevel::Error);
+        const LookupTableAsset* lutAsset = RPI::GetDataFromAnyAsset<LookupTableAsset>(asset);
+
+        if (lutAsset == nullptr)
         {
-            AZ_Assert(displayMapperParameters != nullptr, "The pOutParameters must not to be null pointer.");
-            if (displayMapperParameters == nullptr)
-            {
-                return;
-            }
-
-            // These values in the ODT parameter are taken from the reference ACES transform. 
-            //  
-            // The original ACES references.
-            // Common:
-            // https://github.com/ampas/aces-dev/blob/master/transforms/ctl/lib/ACESlib.ODT_Common.ctl
-            // For sRGB:
-            // https://github.com/ampas/aces-dev/tree/master/transforms/ctl/odt/sRGB
-            displayMapperParameters->m_cinemaLimits[0] = 0.02f;
-            displayMapperParameters->m_cinemaLimits[1] = 48.0f;
-            displayMapperParameters->m_acesSplineParams = GetAcesODTParameters(OutputDeviceTransformType_48Nits);
-            displayMapperParameters->m_OutputDisplayTransformFlags = AlterSurround | ApplyDesaturation | ApplyCATD60toD65;
-            displayMapperParameters->m_OutputDisplayTransformMode = Srgb;
-            ColorConvertionMatrixType   colorMatrixType = XYZ_To_Rec709;
-            switch (displayMapperParameters->m_OutputDisplayTransformMode)
-            {
-            case Srgb:
-                colorMatrixType = XYZ_To_Rec709;
-                break;
-            case PerceptualQuantizer:
-            case Ldr:
-                colorMatrixType = XYZ_To_Bt2020;
-                break;
-            default:
-                break;
-            }
-            displayMapperParameters->m_XYZtoDisplayPrimaries = GetColorConvertionMatrix(colorMatrixType);
-
-            displayMapperParameters->m_surroundGamma = 0.9811f;
-            displayMapperParameters->m_gamma = 2.2f;
+            AZ_Error("AcesDisplayMapperFeatureProcessor", false, "Unable to read LUT from asset.");
+            asset.Release();
+            return;
         }
 
-        void AcesDisplayMapperFeatureProcessor::ApplyHdrOdtParameters(DisplayMapperParameters* displayMapperParameters, const OutputDeviceTransformType& odtType)
+        // The first row of numbers in a 3dl file is a number of vertices that partition the space from [0,..1023]
+        // This assumes that the vertices are evenly spaced apart. Non-uniform spacing is supported by the format,
+        // but haven't been encountered yet.
+        const size_t lutSize = lutAsset->m_intervals.size();
+
+        if (lutSize == 0)
         {
-            AZ_Assert(displayMapperParameters != nullptr, "The pOutParameters must not to be null pointer.");
-            if (displayMapperParameters == nullptr)
-            {
-                return;
-            }
-
-            // Dynamic range limit values taken from NVIDIA HDR sample. 
-            // These values represent and low and high end of the dynamic range in terms of stops from middle grey (0.18)
-            float lowerDynamicRangeInStops = -12.f;
-            float higherDynamicRangeInStops = 10.f;
-            const float MIDDLE_GREY = 0.18f;
-
-            switch (odtType)
-            {
-            case OutputDeviceTransformType_1000Nits:
-                higherDynamicRangeInStops = 10.f;
-                break;
-            case OutputDeviceTransformType_2000Nits:
-                higherDynamicRangeInStops = 11.f;
-                break;
-            case OutputDeviceTransformType_4000Nits:
-                higherDynamicRangeInStops = 12.f;
-                break;
-            default:
-                AZ_Assert(false, "Invalid output device transform type.");
-                break;
-            }
-
-            displayMapperParameters->m_cinemaLimits[0] = MIDDLE_GREY * exp2(lowerDynamicRangeInStops);
-            displayMapperParameters->m_cinemaLimits[1] = MIDDLE_GREY * exp2(higherDynamicRangeInStops);
-            displayMapperParameters->m_acesSplineParams = GetAcesODTParameters(odtType);
-            displayMapperParameters->m_OutputDisplayTransformFlags = AlterSurround | ApplyDesaturation | ApplyCATD60toD65;
-            displayMapperParameters->m_OutputDisplayTransformMode = PerceptualQuantizer;
-            ColorConvertionMatrixType   colorMatrixType = XYZ_To_Bt2020;
-            displayMapperParameters->m_XYZtoDisplayPrimaries = GetColorConvertionMatrix(colorMatrixType);
-
-            // Surround gamma value is from the dim surround gamma from the ACES reference transforms.
-            // https://github.com/ampas/aces-dev/blob/master/transforms/ctl/lib/ACESlib.ODT_Common.ctl
-            displayMapperParameters->m_surroundGamma = 0.9811f;
-            displayMapperParameters->m_gamma = 1.0f; // gamma not used with perceptual quantizer, but just set to 1.0 anyways
+            AZ_Error("AcesDisplayMapperFeatureProcessor", false, "Lut asset has invalid size.");
+            asset.Release();
+            return;
         }
 
-        OutputDeviceTransformType AcesDisplayMapperFeatureProcessor::GetOutputDeviceTransformType(RHI::Format bufferFormat)
+        // Create a buffer of half floats from the LUT and use it to initialize a 3d texture.
+
+        const size_t kChannels = 4;
+        const size_t kChannelBytes = 2;
+        const size_t bytesPerRow = lutSize * kChannels * kChannelBytes;
+        const size_t bytesPerSlice = bytesPerRow * lutSize;
+
+        AZStd::vector<uint16_t> u16Buffer;
+        const size_t bufferSize = lutSize * lutSize * lutSize * kChannels;
+        u16Buffer.resize(bufferSize);
+
+        for (size_t slice = 0; slice < lutSize; slice++)
         {
-            OutputDeviceTransformType outputDeviceTransformType = OutputDeviceTransformType_48Nits;
-            if (bufferFormat == RHI::Format::R8G8B8A8_UNORM ||
-                bufferFormat == RHI::Format::B8G8R8A8_UNORM)
+            for (size_t column = 0; column < lutSize; column++)
             {
-                outputDeviceTransformType = OutputDeviceTransformType_48Nits;
-            }
-            else if (bufferFormat == RHI::Format::R10G10B10A2_UNORM)
-            {
-                outputDeviceTransformType = OutputDeviceTransformType_1000Nits;
-            }
-            else
-            {
-                AZ_Assert(false, "Not yet supported.");
-                // To work normally on unsupported environment, initialize the display parameters by OutputDeviceTransformType_48Nits.
-                outputDeviceTransformType = OutputDeviceTransformType_48Nits;
-            }
-            return outputDeviceTransformType;
-        }
-
-        void AcesDisplayMapperFeatureProcessor::GetAcesDisplayMapperParameters(DisplayMapperParameters* displayMapperParameters, OutputDeviceTransformType odtType)
-        {
-            switch (odtType)
-            {
-            case OutputDeviceTransformType_48Nits:
-                ApplyLdrOdtParameters(displayMapperParameters);
-                break;
-            case OutputDeviceTransformType_1000Nits:
-            case OutputDeviceTransformType_2000Nits:
-            case OutputDeviceTransformType_4000Nits:
-                ApplyHdrOdtParameters(displayMapperParameters, odtType);
-                break;
-            default:
-                AZ_Assert(false, "This ODT type[%d] is not supported.", odtType);
-                break;
-            }
-        }
-
-        void AcesDisplayMapperFeatureProcessor::GetOwnedLut(DisplayMapperLut& displayMapperLut, const AZ::Name& lutName)
-        {
-            auto it = m_ownedLuts.find(lutName);
-            if (it == m_ownedLuts.end())
-            {
-                InitializeLutImage(lutName);
-                it = m_ownedLuts.find(lutName);
-                AZ_Assert(it != m_ownedLuts.end(), "AcesDisplayMapperFeatureProcessor unable to create LUT %s", lutName.GetCStr());
-            }
-            displayMapperLut = it->second;
-        }
-
-        void AcesDisplayMapperFeatureProcessor::GetDisplayMapperLut(DisplayMapperLut& displayMapperLut)
-        {
-            const AZ::Name acesLutName("AcesLutImage");
-            auto it = m_ownedLuts.find(acesLutName);
-            if (it == m_ownedLuts.end())
-            {
-                InitializeLutImage(acesLutName);
-
-                it = m_ownedLuts.find(acesLutName);
-                AZ_Assert(it != m_ownedLuts.end(), "AcesDisplayMapperFeatureProcessor unable to create ACES LUT image");
-            }
-            displayMapperLut = it->second;
-        }
-
-        void AcesDisplayMapperFeatureProcessor::GetLutFromAssetLocation(DisplayMapperAssetLut& displayMapperAssetLut, const AZStd::string& assetPath)
-        {
-            Data::AssetId assetId = RPI::AssetUtils::GetAssetIdForProductPath(assetPath.c_str(), RPI::AssetUtils::TraceLevel::Error);
-            GetLutFromAssetId(displayMapperAssetLut, assetId);
-        }
-
-        void AcesDisplayMapperFeatureProcessor::GetLutFromAssetId(DisplayMapperAssetLut& displayMapperAssetLut, const AZ::Data::AssetId assetId)
-        {
-            if (!assetId.IsValid())
-            {
-                return;
-            }
-
-            // Check first if this already exists
-            auto it = m_assetLuts.find(assetId.ToString<AZStd::string>());
-            if (it != m_assetLuts.end())
-            {
-                displayMapperAssetLut = it->second;
-                return;
-            }
-
-            // Read the lut which is a .3dl file embedded within an azasset file.
-            Data::Asset<RPI::AnyAsset> asset = RPI::AssetUtils::LoadAssetById<RPI::AnyAsset>(assetId, RPI::AssetUtils::TraceLevel::Error);
-            const LookupTableAsset* lutAsset = RPI::GetDataFromAnyAsset<LookupTableAsset>(asset);
-
-            if (lutAsset == nullptr)
-            {
-                AZ_Error("AcesDisplayMapperFeatureProcessor", false, "Unable to read LUT from asset.");
-                asset.Release();
-                return;
-            }
-
-            // The first row of numbers in a 3dl file is a number of vertices that partition the space from [0,..1023]
-            // This assumes that the vertices are evenly spaced apart. Non-uniform spacing is supported by the format,
-            // but haven't been encountered yet.
-            uint32_t lutSize = static_cast<uint32_t>(lutAsset->m_intervals.size());
-
-            if (lutSize == 0)
-            {
-                AZ_Error("AcesDisplayMapperFeatureProcessor", false, "Lut asset has invalid size.");
-                asset.Release();
-                return;
-            }
-
-            // The vertices in the file are given as a positive integer value in [0,..4095] and need to be normalized
-            // and stored into a linear unaligned buffer used to initialize the streaming image.
-            const float normalizeValue = 4095.0f;
-            const int kChannels = 4;
-            const int kChannelBytes = 2;
-            int bytesPerRow = lutSize * kChannels * kChannelBytes;
-            int bytesPerSlice = bytesPerRow * lutSize;
-
-            AZStd::vector<uint16_t> u16Buffer;
-            size_t bufferSize = (bytesPerSlice * lutSize) / sizeof(uint16_t);
-            u16Buffer.resize(bufferSize);
-            uint16_t* data = u16Buffer.data();
-            for (int slice = 0; slice < (int)lutSize; slice++)
-            {
-                for (int column = 0; column < (int)lutSize; column++)
+                for (size_t row = 0; row < lutSize; row++)
                 {
-                    for (int row = 0; row < (int)lutSize; row++)
-                    {
-                        // Index in the LUT texture data
-                        int idx = (column * kChannels) +
-                            (bytesPerRow * row / sizeof(uint16_t)) +
-                            ((bytesPerSlice * slice) / sizeof(uint16_t));
+                    // Index in the LUT texture data
+                    size_t idx = (column * kChannels) +
+                        ((bytesPerRow * row) / kChannelBytes) +
+                        ((bytesPerSlice * slice) / kChannelBytes);
 
-                        // Vertices the .3dl file are listed first by increasing slice, then row, and finally column coordinate
-                        // This corresponds to blue, green, and red channels, respectively.
-                        int assetIdx = slice + lutSize * row + (lutSize * lutSize * column);
+                    // Vertices the .3dl file are listed first by increasing slice, then row, and finally column coordinate
+                    // This corresponds to blue, green, and red channels, respectively.
+                    size_t assetIdx = slice + lutSize * row + (lutSize * lutSize * column);
 
-                        AZ::u64 red = lutAsset->m_values[assetIdx * 3 + 0];
-                        AZ::u64 green = lutAsset->m_values[assetIdx * 3 + 1];
-                        AZ::u64 blue = lutAsset->m_values[assetIdx * 3 + 2];
-                        data[idx + 0] = ConvertFloatToHalf(static_cast<float>(red) / normalizeValue);
-                        data[idx + 1] = ConvertFloatToHalf(static_cast<float>(green) / normalizeValue);
-                        data[idx + 2] = ConvertFloatToHalf(static_cast<float>(blue) / normalizeValue);
-                        data[idx + 3] = 0x3b00; // 1.0 in half
-                    }
+                    AZ::u64 red = lutAsset->m_values[assetIdx * 3 + 0];
+                    AZ::u64 green = lutAsset->m_values[assetIdx * 3 + 1];
+                    AZ::u64 blue = lutAsset->m_values[assetIdx * 3 + 2];
+                    
+                    // The vertices in the file are given as a positive integer value in [0,..4095] and need to be normalized
+                    constexpr float NormalizeValue = 4095.0f;
+
+                    u16Buffer[idx + 0] = ConvertFloatToHalf(static_cast<float>(red) / NormalizeValue);
+                    u16Buffer[idx + 1] = ConvertFloatToHalf(static_cast<float>(green) / NormalizeValue);
+                    u16Buffer[idx + 2] = ConvertFloatToHalf(static_cast<float>(blue) / NormalizeValue);
+                    u16Buffer[idx + 3] = 0x3b00; // 1.0 in half
                 }
             }
-
-            asset.Release();
-
-            Data::Instance<RPI::StreamingImagePool> streamingImagePool = RPI::ImageSystemInterface::Get()->GetSystemStreamingPool();
-
-            RHI::Size imageSize;
-            imageSize.m_width = static_cast<uint32_t>(lutSize);
-            imageSize.m_height = static_cast<uint32_t>(lutSize);
-            imageSize.m_depth = static_cast<uint32_t>(lutSize);
-            size_t imageDataSize = bytesPerSlice * lutSize;
-
-            Data::Instance<RPI::StreamingImage> lutStreamingImage = RPI::StreamingImage::CreateFromCpuData(
-                *streamingImagePool, RHI::ImageDimension::Image3D, imageSize, LutFormat, data, imageDataSize);
-
-            AZ_Error("AcesDisplayMapperFeatureProcessor", lutStreamingImage, "Failed to initialize the lut assetId %s.", assetId.ToString<AZStd::string>().c_str());
-
-            DisplayMapperAssetLut assetLut;
-            assetLut.m_lutStreamingImage = lutStreamingImage;
-
-            // Add to the list of LUT asset resources
-            m_assetLuts.insert(AZStd::pair<AZStd::string, DisplayMapperAssetLut>(assetId.ToString<AZStd::string>(), assetLut));
-            displayMapperAssetLut = assetLut;
         }
 
-        void AcesDisplayMapperFeatureProcessor::InitializeImagePool()
+        asset.Release();
+
+        Data::Instance<RPI::StreamingImagePool> streamingImagePool = RPI::ImageSystemInterface::Get()->GetSystemStreamingPool();
+
+        RHI::Size imageSize;
+        imageSize.m_width = static_cast<uint32_t>(lutSize);
+        imageSize.m_height = static_cast<uint32_t>(lutSize);
+        imageSize.m_depth = static_cast<uint32_t>(lutSize);
+        size_t imageDataSize = bytesPerSlice * lutSize;
+
+        Data::Instance<RPI::StreamingImage> lutStreamingImage = RPI::StreamingImage::CreateFromCpuData(
+            *streamingImagePool, RHI::ImageDimension::Image3D, imageSize, LutFormat, u16Buffer.data(), imageDataSize);
+
+        AZ_Error("AcesDisplayMapperFeatureProcessor", lutStreamingImage, "Failed to initialize the lut assetId %s.", assetId.ToString<AZStd::string>().c_str());
+
+        DisplayMapperAssetLut assetLut;
+        assetLut.m_lutStreamingImage = lutStreamingImage;
+
+        // Add to the list of LUT asset resources
+        m_assetLuts.insert(AZStd::pair<AZStd::string, DisplayMapperAssetLut>(assetId.ToString<AZStd::string>(), assetLut));
+        displayMapperAssetLut = assetLut;
+    }
+
+    void AcesDisplayMapperFeatureProcessor::InitializeImagePool()
+    {
+        AZ::RHI::Factory& factory = RHI::Factory::Get();
+        m_displayMapperImagePool = factory.CreateImagePool();
+        m_displayMapperImagePool->SetName(Name("DisplayMapperImagePool"));
+
+        RHI::ImagePoolDescriptor   imagePoolDesc = {};
+        imagePoolDesc.m_bindFlags = RHI::ImageBindFlags::ShaderReadWrite;
+        imagePoolDesc.m_budgetInBytes = ImagePoolBudget;
+
+        RHI::Device* device = RHI::RHISystemInterface::Get()->GetDevice();
+        RHI::ResultCode resultCode = m_displayMapperImagePool->Init(*device, imagePoolDesc);
+        if (resultCode != RHI::ResultCode::Success)
         {
-            AZ::RHI::Factory& factory = RHI::Factory::Get();
-            m_displayMapperImagePool = factory.CreateImagePool();
-            m_displayMapperImagePool->SetName(Name("DisplayMapperImagePool"));
-
-            RHI::ImagePoolDescriptor   imagePoolDesc = {};
-            imagePoolDesc.m_bindFlags = RHI::ImageBindFlags::ShaderReadWrite;
-            imagePoolDesc.m_budgetInBytes = ImagePoolBudget;
-
-            RHI::Device* device = RHI::RHISystemInterface::Get()->GetDevice();
-            RHI::ResultCode resultCode = m_displayMapperImagePool->Init(*device, imagePoolDesc);
-            if (resultCode != RHI::ResultCode::Success)
-            {
-                AZ_Error("AcesDisplayMapperFeatureProcessor", false, "Failed to initialize image pool.");
-                return;
-            }
+            AZ_Error("AcesDisplayMapperFeatureProcessor", false, "Failed to initialize image pool.");
+            return;
         }
+    }
 
-        void AcesDisplayMapperFeatureProcessor::InitializeLutImage(const AZ::Name& lutName)
+    void AcesDisplayMapperFeatureProcessor::InitializeLutImage(const AZ::Name& lutName)
+    {
+        if (!m_displayMapperImagePool)
         {
-            if (!m_displayMapperImagePool)
-            {
-                InitializeImagePool();
-            }
-
-            DisplayMapperLut lutResource;
-            lutResource.m_lutImage = RHI::Factory::Get().CreateImage();
-            lutResource.m_lutImage->SetName(lutName);
-
-            RHI::ImageInitRequest imageRequest;
-            imageRequest.m_image = lutResource.m_lutImage.get();
-            imageRequest.m_descriptor = RHI::ImageDescriptor::Create3D(RHI::ImageBindFlags::ShaderReadWrite, LutSize, LutSize, LutSize, LutFormat);
-            RHI::ResultCode resultCode = m_displayMapperImagePool->InitImage(imageRequest);
-
-            if (resultCode != RHI::ResultCode::Success)
-            {
-                AZ_Error("AcesDisplayMapperFeatureProcessor", false, "Failed to initialize LUT image.");
-                return;
-            }
-
-            lutResource.m_lutImageViewDescriptor = RHI::ImageViewDescriptor::Create(LutFormat, 0, 0);
-            lutResource.m_lutImageView = lutResource.m_lutImage->GetImageView(lutResource.m_lutImageViewDescriptor);
-            if (!lutResource.m_lutImageView.get())
-            {
-                AZ_Error("AcesDisplayMapperFeatureProcessor", false, "Failed to initialize LUT image view.");
-                return;
-            }
-
-            // Add to the list of lut resources
-            lutResource.m_lutImageView->SetName(lutName);
-            m_ownedLuts[lutName] = lutResource;
+            InitializeImagePool();
         }
 
-        ShaperParams AcesDisplayMapperFeatureProcessor::GetShaperParameters(ShaperPresetType shaperPreset)
+        DisplayMapperLut lutResource;
+        lutResource.m_lutImage = RHI::Factory::Get().CreateImage();
+        lutResource.m_lutImage->SetName(lutName);
+
+        RHI::ImageInitRequest imageRequest;
+        imageRequest.m_image = lutResource.m_lutImage.get();
+        static const int LutSize = 32;
+        imageRequest.m_descriptor = RHI::ImageDescriptor::Create3D(RHI::ImageBindFlags::ShaderReadWrite, LutSize, LutSize, LutSize, LutFormat);
+        RHI::ResultCode resultCode = m_displayMapperImagePool->InitImage(imageRequest);
+
+        if (resultCode != RHI::ResultCode::Success)
         {
-            // Default is a linear shaper with bias 0.0 and scale 1.0. That is, fx = x*1.0 + 0.0
-            ShaperParams shaperParams = { ShaperType::Linear, 0.0, 1.f };
-            OutputDeviceTransformType outputDeviceTransformType = OutputDeviceTransformType::NumOutputDeviceTransformTypes;
-            switch (shaperPreset)
-            {
-            case ShaperPresetType::None:
-                break;
-            case ShaperPresetType::Log2_48_nits:
-                outputDeviceTransformType = OutputDeviceTransformType::OutputDeviceTransformType_48Nits;
-                break;
-            case ShaperPresetType::Log2_1000_nits:
-                outputDeviceTransformType = OutputDeviceTransformType::OutputDeviceTransformType_1000Nits;
-                break;
-            case ShaperPresetType::Log2_2000_nits:
-                outputDeviceTransformType = OutputDeviceTransformType::OutputDeviceTransformType_2000Nits;
-                break;
-            case ShaperPresetType::Log2_4000_nits:
-                outputDeviceTransformType = OutputDeviceTransformType::OutputDeviceTransformType_4000Nits;
-                break;
-            default:
-                AZ_Error("DisplayMapperPass", false, "Invalid shaper preset type.");
-                break;
-            }
-            if (outputDeviceTransformType < OutputDeviceTransformType::NumOutputDeviceTransformTypes)
-            {
-                shaperParams = GetAcesShaperParameters(outputDeviceTransformType);
-            }
-            return shaperParams;
+            AZ_Error("AcesDisplayMapperFeatureProcessor", false, "Failed to initialize LUT image.");
+            return;
         }
 
-        void AcesDisplayMapperFeatureProcessor::GetDefaultDisplayMapperConfiguration(DisplayMapperConfigurationDescriptor& config)
+        lutResource.m_lutImageViewDescriptor = RHI::ImageViewDescriptor::Create(LutFormat, 0, 0);
+        lutResource.m_lutImageView = lutResource.m_lutImage->GetImageView(lutResource.m_lutImageViewDescriptor);
+        if (!lutResource.m_lutImageView.get())
         {
-            // Default configuration is ACES with LDR color grading LUT disabled.
-            config.m_operationType = DisplayMapperOperationType::Aces;
-            config.m_ldrGradingLutEnabled = false;
-            config.m_ldrColorGradingLut.Release();
+            AZ_Error("AcesDisplayMapperFeatureProcessor", false, "Failed to initialize LUT image view.");
+            return;
         }
 
-        void AcesDisplayMapperFeatureProcessor::RegisterDisplayMapperConfiguration(const DisplayMapperConfigurationDescriptor& config)
-        {
-            m_displayMapperConfiguration = config;
-        }
+        // Add to the list of lut resources
+        lutResource.m_lutImageView->SetName(lutName);
+        m_ownedLuts[lutName] = lutResource;
+    }
 
-        DisplayMapperConfigurationDescriptor AcesDisplayMapperFeatureProcessor::GetDisplayMapperConfiguration()
+    ShaperParams AcesDisplayMapperFeatureProcessor::GetShaperParameters(ShaperPresetType shaperPreset, float customMinEv, float customMaxEv)
+    {
+        // Default is a linear shaper with bias 0.0 and scale 1.0. That is, fx = x*1.0 + 0.0
+        ShaperParams shaperParams = { ShaperType::Linear, 0.0, 1.f };
+        switch (shaperPreset)
         {
-            return m_displayMapperConfiguration;
+        case ShaperPresetType::None:
+            break;
+        case ShaperPresetType::Log2_48Nits:
+            shaperParams = GetAcesShaperParameters(OutputDeviceTransformType::OutputDeviceTransformType_48Nits);
+            break;
+        case ShaperPresetType::Log2_1000Nits:
+            shaperParams = GetAcesShaperParameters(OutputDeviceTransformType::OutputDeviceTransformType_1000Nits);
+            break;
+        case ShaperPresetType::Log2_2000Nits:
+            shaperParams = GetAcesShaperParameters(OutputDeviceTransformType::OutputDeviceTransformType_2000Nits);
+            break;
+        case ShaperPresetType::Log2_4000Nits:
+            shaperParams = GetAcesShaperParameters(OutputDeviceTransformType::OutputDeviceTransformType_4000Nits);
+            break;
+        case ShaperPresetType::LinearCustomRange:
+        {
+            // Map the range min exposure - max exposure to 0-1. Convert EV values to linear values here to avoid that work in the shader.
+            // Shader equation becomes (x - bias) / scale;
+            constexpr float MediumGray = 0.18f;
+            const float minValue = MediumGray * powf(2, customMinEv);
+            const float maxValue = MediumGray * powf(2, customMaxEv);
+            shaperParams.m_type = ShaperType::Linear;
+            shaperParams.m_scale = 1.0f / (maxValue - minValue);
+            shaperParams.m_bias = -minValue * shaperParams.m_scale;
+            break;
         }
-    } // namespace Render
-} // namespace AZ
+        case ShaperPresetType::Log2CustomRange:
+            shaperParams = GetLog2ShaperParameters(customMinEv, customMaxEv);
+            break;
+        case ShaperPresetType::PqSmpteSt2084:
+            shaperParams.m_type = ShaperType::PqSmpteSt2084;
+            break;
+        default:
+            AZ_Error("DisplayMapperPass", false, "Invalid shaper preset type.");
+            break;
+        }
+        return shaperParams;
+    }
+
+    void AcesDisplayMapperFeatureProcessor::GetDefaultDisplayMapperConfiguration(DisplayMapperConfigurationDescriptor& config)
+    {
+        // Default configuration is ACES with LDR color grading LUT disabled.
+        config.m_operationType = DisplayMapperOperationType::Aces;
+        config.m_ldrGradingLutEnabled = false;
+        config.m_ldrColorGradingLut.Release();
+    }
+
+    void AcesDisplayMapperFeatureProcessor::RegisterDisplayMapperConfiguration(const DisplayMapperConfigurationDescriptor& config)
+    {
+        m_displayMapperConfiguration = config;
+    }
+
+    DisplayMapperConfigurationDescriptor AcesDisplayMapperFeatureProcessor::GetDisplayMapperConfiguration()
+    {
+        return m_displayMapperConfiguration;
+    }
+} // namespace AZ::Render
diff --git a/Gems/Atom/Feature/Common/Code/Source/DisplayMapper/AcesOutputTransformLutPass.cpp b/Gems/Atom/Feature/Common/Code/Source/DisplayMapper/AcesOutputTransformLutPass.cpp
index a00f879bca..3b2913aefd 100644
--- a/Gems/Atom/Feature/Common/Code/Source/DisplayMapper/AcesOutputTransformLutPass.cpp
+++ b/Gems/Atom/Feature/Common/Code/Source/DisplayMapper/AcesOutputTransformLutPass.cpp
@@ -91,8 +91,8 @@ namespace AZ
                     m_shaderResourceGroup->SetImageView(m_shaderInputLutImageIndex, m_displayMapperLut.m_lutImageView.get());
                 }
 
-                m_shaderResourceGroup->SetConstant(m_shaderInputShaperBiasIndex, m_shaperParams.bias);
-                m_shaderResourceGroup->SetConstant(m_shaderInputShaperScaleIndex, m_shaperParams.scale);
+                m_shaderResourceGroup->SetConstant(m_shaderInputShaperBiasIndex, m_shaperParams.m_bias);
+                m_shaderResourceGroup->SetConstant(m_shaderInputShaperScaleIndex, m_shaperParams.m_scale);
             }
 
             BindPassSrg(context, m_shaderResourceGroup);
diff --git a/Gems/Atom/Feature/Common/Code/Source/DisplayMapper/ApplyShaperLookupTablePass.cpp b/Gems/Atom/Feature/Common/Code/Source/DisplayMapper/ApplyShaperLookupTablePass.cpp
index eec511c07a..f4325f0421 100644
--- a/Gems/Atom/Feature/Common/Code/Source/DisplayMapper/ApplyShaperLookupTablePass.cpp
+++ b/Gems/Atom/Feature/Common/Code/Source/DisplayMapper/ApplyShaperLookupTablePass.cpp
@@ -109,9 +109,9 @@ namespace AZ
                 {
                     m_shaderResourceGroup->SetImageView(m_shaderInputLutImageIndex, m_lutResource.m_lutStreamingImage->GetImageView());
 
-                    m_shaderResourceGroup->SetConstant(m_shaderShaperTypeIndex, m_shaperParams.type);
-                    m_shaderResourceGroup->SetConstant(m_shaderShaperBiasIndex, m_shaperParams.bias);
-                    m_shaderResourceGroup->SetConstant(m_shaderShaperScaleIndex, m_shaperParams.scale);
+                    m_shaderResourceGroup->SetConstant(m_shaderShaperTypeIndex, m_shaperParams.m_type);
+                    m_shaderResourceGroup->SetConstant(m_shaderShaperBiasIndex, m_shaperParams.m_bias);
+                    m_shaderResourceGroup->SetConstant(m_shaderShaperScaleIndex, m_shaperParams.m_scale);
                 }
             }
         }
diff --git a/Gems/Atom/Feature/Common/Code/Source/DisplayMapper/BakeAcesOutputTransformLutPass.cpp b/Gems/Atom/Feature/Common/Code/Source/DisplayMapper/BakeAcesOutputTransformLutPass.cpp
index f7ecfc3461..a8d1b68d63 100644
--- a/Gems/Atom/Feature/Common/Code/Source/DisplayMapper/BakeAcesOutputTransformLutPass.cpp
+++ b/Gems/Atom/Feature/Common/Code/Source/DisplayMapper/BakeAcesOutputTransformLutPass.cpp
@@ -94,8 +94,8 @@ namespace AZ
 
                 m_shaderResourceGroup->SetImageView(m_shaderInputLutImageIndex, m_displayMapperLut.m_lutImageView.get());
 
-                m_shaderResourceGroup->SetConstant(m_shaderInputShaperBiasIndex, m_shaperParams.bias);
-                m_shaderResourceGroup->SetConstant(m_shaderInputShaperScaleIndex, m_shaperParams.scale);
+                m_shaderResourceGroup->SetConstant(m_shaderInputShaperBiasIndex, m_shaperParams.m_bias);
+                m_shaderResourceGroup->SetConstant(m_shaderInputShaperScaleIndex, m_shaperParams.m_scale);
             }
 
             BindPassSrg(context, m_shaderResourceGroup);
diff --git a/Gems/Atom/Feature/Common/Code/Source/PostProcess/LookModification/LookModificationSettings.cpp b/Gems/Atom/Feature/Common/Code/Source/PostProcess/LookModification/LookModificationSettings.cpp
index d2e28e3a68..cbc357db61 100644
--- a/Gems/Atom/Feature/Common/Code/Source/PostProcess/LookModification/LookModificationSettings.cpp
+++ b/Gems/Atom/Feature/Common/Code/Source/PostProcess/LookModification/LookModificationSettings.cpp
@@ -26,6 +26,8 @@ namespace AZ
             seed = TypeHash64(m_overrideStrength, seed);
             seed = TypeHash64(m_assetId.GetId(), seed);
             seed = TypeHash64(m_shaperPreset, seed);
+            seed = TypeHash64(m_customMinExposure, seed);
+            seed = TypeHash64(m_customMaxExposure, seed);
             return seed;
         }
 
@@ -50,6 +52,9 @@ namespace AZ
                 lutBlend.m_intensity = GetColorGradingLutIntensity();
                 lutBlend.m_overrideStrength = GetColorGradingLutOverride() * alpha;
                 lutBlend.m_assetId = lutAssetId;
+                lutBlend.m_shaperPreset = GetShaperPresetType();
+                lutBlend.m_customMinExposure = GetCustomMinExposure();
+                lutBlend.m_customMaxExposure = GetCustomMaxExposure();
                 target->AddLutBlend(lutBlend);
             }
         }
@@ -87,6 +92,9 @@ namespace AZ
                     blendItem.m_intensity = GetColorGradingLutIntensity();
                     blendItem.m_overrideStrength = GetColorGradingLutOverride();
                     blendItem.m_assetId = GetColorGradingLut();
+                    blendItem.m_shaperPreset = GetShaperPresetType();
+                    blendItem.m_customMinExposure = GetCustomMinExposure();
+                    blendItem.m_customMaxExposure = GetCustomMaxExposure();
                     m_lutBlendStack.insert(m_lutBlendStack.begin(), blendItem);
                 }
             }
diff --git a/Gems/Atom/Feature/Common/Code/Source/PostProcess/LookModification/LookModificationSettings.h b/Gems/Atom/Feature/Common/Code/Source/PostProcess/LookModification/LookModificationSettings.h
index 19bf07010b..d91a029ced 100644
--- a/Gems/Atom/Feature/Common/Code/Source/PostProcess/LookModification/LookModificationSettings.h
+++ b/Gems/Atom/Feature/Common/Code/Source/PostProcess/LookModification/LookModificationSettings.h
@@ -33,7 +33,10 @@ namespace AZ
             //! Asset ID of LUT
             Data::Asset<RPI::AnyAsset> m_assetId;
             //! Shaper preset type
-            ShaperPresetType m_shaperPreset = AZ::Render::ShaperPresetType::Log2_48_nits;
+            ShaperPresetType m_shaperPreset = AZ::Render::ShaperPresetType::Log2_48Nits;
+            //! When shaper preset is custom, these values set min and max exposure.
+            float m_customMinExposure = -6.5;
+            float m_customMaxExposure = 6.5;
             HashValue64 GetHash(HashValue64 seed) const;
         };
 
diff --git a/Gems/Atom/Feature/Common/Code/Source/PostProcessing/BlendColorGradingLutsPass.cpp b/Gems/Atom/Feature/Common/Code/Source/PostProcessing/BlendColorGradingLutsPass.cpp
index da680d80cf..8631ae2eb3 100644
--- a/Gems/Atom/Feature/Common/Code/Source/PostProcessing/BlendColorGradingLutsPass.cpp
+++ b/Gems/Atom/Feature/Common/Code/Source/PostProcessing/BlendColorGradingLutsPass.cpp
@@ -21,7 +21,7 @@ namespace AZ
     namespace Render
     {
         static const char* const NumSourceLutsShaderVariantOptionName{ "o_numSourceLuts" };
-
+        
         RPI::Ptr<BlendColorGradingLutsPass> BlendColorGradingLutsPass::Create(const RPI::PassDescriptor& descriptor)
         {
             RPI::Ptr<BlendColorGradingLutsPass> pass = aznew BlendColorGradingLutsPass(descriptor);
@@ -151,9 +151,9 @@ namespace AZ
             {
                 m_shaderResourceGroup->SetImageView(m_shaderInputBlendedLutImageIndex, m_blendedLut.m_lutImageView.get());
                 m_shaderResourceGroup->SetConstant(m_shaderInputBlendedLutDimensionsIndex, m_blendedLutDimensions);
-                m_shaderResourceGroup->SetConstant(m_shaderInputBlendedLutShaperTypeIndex, m_blendedLutShaperParams.type);
-                m_shaderResourceGroup->SetConstant(m_shaderInputBlendededLutShaperBiasIndex, m_blendedLutShaperParams.bias);
-                m_shaderResourceGroup->SetConstant(m_shaderInputBlendededLutShaperScaleIndex, m_blendedLutShaperParams.scale);
+                m_shaderResourceGroup->SetConstant(m_shaderInputBlendedLutShaperTypeIndex, m_blendedLutShaperParams.m_type);
+                m_shaderResourceGroup->SetConstant(m_shaderInputBlendededLutShaperBiasIndex, m_blendedLutShaperParams.m_bias);
+                m_shaderResourceGroup->SetConstant(m_shaderInputBlendededLutShaperScaleIndex, m_blendedLutShaperParams.m_scale);
                 m_shaderResourceGroup->SetConstant(m_shaderInputWeight0Index, m_weights[0]);
                 m_shaderResourceGroup->SetConstant(m_shaderInputWeight1Index, m_weights[1]);
                 m_shaderResourceGroup->SetConstant(m_shaderInputWeight2Index, m_weights[2]);
@@ -163,33 +163,33 @@ namespace AZ
                 if (m_colorGradingLuts[0].m_lutStreamingImage)
                 {
                     m_shaderResourceGroup->SetImageView(m_shaderInputSourceLut1ImageIndex, m_colorGradingLuts[0].m_lutStreamingImage->GetImageView());
-                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut1ShaperTypeIndex, m_colorGradingShaperParams[0].type);
-                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut1ShaperBiasIndex, m_colorGradingShaperParams[0].bias);
-                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut1ShaperScaleIndex, m_colorGradingShaperParams[0].scale);
+                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut1ShaperTypeIndex, m_colorGradingShaperParams[0].m_type);
+                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut1ShaperBiasIndex, m_colorGradingShaperParams[0].m_bias);
+                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut1ShaperScaleIndex, m_colorGradingShaperParams[0].m_scale);
                 }
 
                 if (m_colorGradingLuts[1].m_lutStreamingImage)
                 {
                     m_shaderResourceGroup->SetImageView(m_shaderInputSourceLut2ImageIndex, m_colorGradingLuts[1].m_lutStreamingImage->GetImageView());
-                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut2ShaperTypeIndex, m_colorGradingShaperParams[1].type);
-                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut2ShaperBiasIndex, m_colorGradingShaperParams[1].bias);
-                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut2ShaperScaleIndex, m_colorGradingShaperParams[1].scale);
+                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut2ShaperTypeIndex, m_colorGradingShaperParams[1].m_type);
+                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut2ShaperBiasIndex, m_colorGradingShaperParams[1].m_bias);
+                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut2ShaperScaleIndex, m_colorGradingShaperParams[1].m_scale);
                 }
 
                 if (m_colorGradingLuts[2].m_lutStreamingImage)
                 {
                     m_shaderResourceGroup->SetImageView(m_shaderInputSourceLut3ImageIndex, m_colorGradingLuts[2].m_lutStreamingImage->GetImageView());
-                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut3ShaperTypeIndex, m_colorGradingShaperParams[2].type);
-                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut3ShaperBiasIndex, m_colorGradingShaperParams[2].bias);
-                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut3ShaperScaleIndex, m_colorGradingShaperParams[2].scale);
+                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut3ShaperTypeIndex, m_colorGradingShaperParams[2].m_type);
+                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut3ShaperBiasIndex, m_colorGradingShaperParams[2].m_bias);
+                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut3ShaperScaleIndex, m_colorGradingShaperParams[2].m_scale);
                 }
 
                 if (m_colorGradingLuts[3].m_lutStreamingImage)
                 {
                     m_shaderResourceGroup->SetImageView(m_shaderInputSourceLut4ImageIndex, m_colorGradingLuts[3].m_lutStreamingImage->GetImageView());
-                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut4ShaperTypeIndex, m_colorGradingShaperParams[3].type);
-                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut4ShaperBiasIndex, m_colorGradingShaperParams[3].bias);
-                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut4ShaperScaleIndex, m_colorGradingShaperParams[3].scale);
+                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut4ShaperTypeIndex, m_colorGradingShaperParams[3].m_type);
+                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut4ShaperBiasIndex, m_colorGradingShaperParams[3].m_bias);
+                    m_shaderResourceGroup->SetConstant(m_shaderInputSourceLut4ShaperScaleIndex, m_colorGradingShaperParams[3].m_scale);
                 }
 
                 if (m_shaderResourceGroup->HasShaderVariantKeyFallbackEntry())
@@ -244,7 +244,170 @@ namespace AZ
             m_blendedLutShaperParams = shaperParams;
         }
 
+        
+        AZStd::optional<ShaperParams> BlendColorGradingLutsPass::GetCommonShaperParams() const
+        {
+            LookModificationSettings* settings = GetLookModificationSettings();
+            if (settings)
+            {
+                settings->PrepareLutBlending();
+
+                ShaperPresetType type = ShaperPresetType::NumShaperTypes;
+                float customMinExposure = 0.0;
+                float customMaxExposure = 0.0;
+
+                for (size_t lutIndex = 0; lutIndex < settings->GetLutBlendStackSize(); lutIndex++)
+                {
+                    LutBlendItem& lutBlendItem = settings->GetLutBlendItem(lutIndex);
+
+                    if (lutIndex == 0)
+                    {
+                        type = lutBlendItem.m_shaperPreset;
+                        customMinExposure = lutBlendItem.m_customMinExposure;
+                        customMaxExposure = lutBlendItem.m_customMaxExposure;
+                    }
+                    else if (type != lutBlendItem.m_shaperPreset)
+                    {
+                        // Shapers are different
+                        return AZStd::nullopt;
+                    }
+                    else if (type == ShaperPresetType::LinearCustomRange || type == ShaperPresetType::Log2CustomRange)
+                    {
+                        if (lutBlendItem.m_customMinExposure != customMinExposure ||
+                            lutBlendItem.m_customMaxExposure != customMaxExposure)
+                        {
+                            // Shapers are same, but custom exposure for custom type is different.
+                            return AZStd::nullopt;
+                        }
+                    }
+                }
+
+                // Only calculate shaper params when there's at least one lut blend.
+                if (settings->GetLutBlendStackSize() > 0)
+                {
+                    return AcesDisplayMapperFeatureProcessor::GetShaperParameters(type, customMinExposure, customMaxExposure);
+                }
+            }
+            return AZStd::nullopt;
+        }
+
         void BlendColorGradingLutsPass::CheckLutBlendSettings()
+        {
+            LookModificationSettings* settings = GetLookModificationSettings();
+            if (settings)
+            {
+                settings->PrepareLutBlending();
+
+                // Early out if the settings have not chanced
+                HashValue64 hash = settings->GetHash();
+                if (hash == m_lutBlendHash)
+                {
+                    return;
+                }
+                m_lutBlendHash = hash;
+
+                m_needToUpdateLut = true;
+
+                // Calculate all the weights and LUT assets and check if there has been a change
+                // Only the top N LUTs will be blended where N = LookModificationSettings::MaxBlendLuts
+                // Weight 0 is used for the base color, and the other weights are for the LUTs in increasing priority
+                size_t numLuts = settings->GetLutBlendStackSize();
+
+                float intensity[LookModificationSettings::MaxBlendLuts];
+                float one_intensity[LookModificationSettings::MaxBlendLuts];
+                float over[LookModificationSettings::MaxBlendLuts];
+                float one_over[LookModificationSettings::MaxBlendLuts];
+
+                for (int curLutIndex = 0; curLutIndex < LookModificationSettings::MaxBlendLuts; curLutIndex++)
+                {
+                    intensity[curLutIndex] = 0.f;
+                    one_intensity[curLutIndex] = 1.f;
+                    over[curLutIndex] = 0.f;
+                    one_over[curLutIndex] = 1.f;
+                }
+
+                int current = 0;
+                for (size_t lutIndex = 0; lutIndex < numLuts; lutIndex++)
+                {
+                    LutBlendItem& lutBlendItem = settings->GetLutBlendItem(lutIndex);
+                    const auto assetId = lutBlendItem.m_assetId.GetId();
+
+                    if (assetId.IsValid())
+                    {
+                        AcesDisplayMapperFeatureProcessor* dmfp = GetScene()->GetFeatureProcessor<AcesDisplayMapperFeatureProcessor>();
+                        dmfp->GetLutFromAssetId(m_colorGradingLuts[current], assetId);
+                        if (!m_colorGradingLuts[current].m_lutStreamingImage)
+                        {
+                            AZ_Warning("BlendColorGradingLutsPass", false, "Unable to load grading LUT from asset %s",
+                                lutBlendItem.m_assetId.ToString<AZStd::string>().c_str());
+                            // Skip this LUT
+                            continue;
+                        }
+                    }
+
+                    intensity[current] = lutBlendItem.m_intensity;
+                    one_intensity[current] = 1.0f - lutBlendItem.m_intensity;
+                    over[current] = lutBlendItem.m_overrideStrength;
+                    one_over[current] = 1.0f - lutBlendItem.m_overrideStrength;
+
+                    m_colorGradingShaperParams[current] = AcesDisplayMapperFeatureProcessor::GetShaperParameters(
+                        lutBlendItem.m_shaperPreset,
+                        lutBlendItem.m_customMinExposure,
+                        lutBlendItem.m_customMaxExposure
+                    );
+
+                    ++current;
+                    if (current == LookModificationSettings::MaxBlendLuts)
+                    {
+                        break;
+                    }
+                }
+
+                m_weights[0] = 0.f;
+                // Handle the case where there are no LUTs to be blended, and hence an identity LUT will be generated
+                if (current == 0)
+                {
+                    m_weights[0] = 1.f;
+                    // These weights would not be used in the shader in this case, but setting to zero anyways.
+                    for (int lutIndex = 1; lutIndex < LookModificationSettings::MaxBlendLuts + 1; lutIndex++)
+                    {
+                        m_weights[lutIndex] = 0.f;
+                    }
+                }
+                else
+                {
+                    // Compute all the weights
+                    // First compute the weight of the ungraded color value
+                    for (int lutIndex = 0; lutIndex < current; lutIndex++)
+                    {
+                        float weight = one_intensity[lutIndex] * over[lutIndex];
+                        for (int overrideLutIndex = lutIndex + 1; overrideLutIndex < LookModificationSettings::MaxBlendLuts; overrideLutIndex++)
+                        {
+                            weight *= one_over[overrideLutIndex];
+                        }
+                        m_weights[0] += weight;
+                    }
+                    // Then compute the weights for the LUTs
+                    for (int weightIndex = 0; weightIndex < current; weightIndex++)
+                    {
+                        m_weights[weightIndex + 1] = intensity[weightIndex] * over[weightIndex];
+                        for (int lutIndex = weightIndex + 1; lutIndex < LookModificationSettings::MaxBlendLuts; lutIndex++)
+                        {
+                            m_weights[weightIndex + 1] *= one_over[lutIndex];
+                        }
+                    }
+                }
+
+                // If the number of source LUTs have changed, the shader variant will need to be updated
+                if (m_numSourceLuts != current)
+                {
+                    m_numSourceLuts = current;
+                    m_needToUpdateShaderVariant = true;
+                }
+            }
+        }
+
+        LookModificationSettings* BlendColorGradingLutsPass::GetLookModificationSettings() const
         {
             AZ::RPI::Scene* scene = GetScene();
             if (scene)
@@ -259,109 +422,12 @@ namespace AZ
                         LookModificationSettings* settings = postProcessSettings->GetLookModificationSettings();
                         if (settings)
                         {
-                            settings->PrepareLutBlending();
-
-                            // Early out if the settings have not chanced
-                            HashValue64 hash = settings->GetHash();
-                            if (hash == m_lutBlendHash)
-                            {
-                                return;
-                            }
-                            m_lutBlendHash = hash;
-
-                            m_needToUpdateLut = true;
-
-                            // Calculate all the weights and LUT assets and check if there has been a change
-                            // Only the top N LUTs will be blended where N = LookModificationSettings::MaxBlendLuts
-                            // Weight 0 is used for the base color, and the other weights are for the LUTs in increasing priority
-                            size_t numLuts = settings->GetLutBlendStackSize();
-                            float intensity[LookModificationSettings::MaxBlendLuts];
-                            float one_intensity[LookModificationSettings::MaxBlendLuts];
-                            float over[LookModificationSettings::MaxBlendLuts];
-                            float one_over[LookModificationSettings::MaxBlendLuts];
-                            for (int curLutIndex = 0; curLutIndex < LookModificationSettings::MaxBlendLuts; curLutIndex++)
-                            {
-                                intensity[curLutIndex] = 0.f;
-                                one_intensity[curLutIndex] = 1.f;
-                                over[curLutIndex] = 0.f;
-                                one_over[curLutIndex] = 1.f;
-                            }
-
-                            int current = 0;
-                            for (size_t lutIndex = 0; lutIndex < numLuts; lutIndex++)
-                            {
-                                LutBlendItem& lutBlendItem = settings->GetLutBlendItem(lutIndex);
-                                auto assetId = lutBlendItem.m_assetId.GetId();
-                                if (assetId.IsValid())
-                                {
-                                    AcesDisplayMapperFeatureProcessor* dmfp = scene->GetFeatureProcessor<AcesDisplayMapperFeatureProcessor>();
-                                    dmfp->GetLutFromAssetId(m_colorGradingLuts[lutIndex], assetId);
-                                    if (!m_colorGradingLuts[lutIndex].m_lutStreamingImage)
-                                    {
-                                        AZ_Warning("BlendColorGradingLutsPass", false, "Unable to load grading LUT from asset %s", lutBlendItem.m_assetId.ToString<AZStd::string>().c_str());
-                                        // Skip this LUT
-                                        continue;
-                                    }
-                                }
-                                intensity[current] = lutBlendItem.m_intensity;
-                                one_intensity[current] = 1.f - intensity[lutIndex];
-                                over[current] = lutBlendItem.m_overrideStrength;
-                                one_over[current] = 1.f - over[lutIndex];
-                                m_colorGradingLutAssets[current] = lutBlendItem.m_assetId;
-                                m_colorGradingShaperPresets[current] = lutBlendItem.m_shaperPreset;
-                                m_colorGradingShaperParams[current] = AcesDisplayMapperFeatureProcessor::GetShaperParameters(m_colorGradingShaperPresets[lutIndex]);
-                                current++;
-                                if (current == LookModificationSettings::MaxBlendLuts)
-                                {
-                                    break;
-                                }
-                            }
-
-                            m_weights[0] = 0.f;
-                            // Handle the case where there are no LUTs to be blended, and hence an identity LUT will be generated
-                            if (current == 0)
-                            {
-                                m_weights[0] = 1.f;
-                                // These weights would not be used in the shader in this case, but setting to zero anyways.
-                                for (int lutIndex = 1; lutIndex < LookModificationSettings::MaxBlendLuts + 1; lutIndex++)
-                                {
-                                    m_weights[lutIndex] = 0.f;
-                                }
-                            }
-                            else
-                            {
-                                // Compute all the weights
-                                // First compute the weight of the ungraded color value
-                                for (int lutIndex = 0; lutIndex < LookModificationSettings::MaxBlendLuts; lutIndex++)
-                                {
-                                    float weight = one_intensity[lutIndex] * over[lutIndex];
-                                    for (int overrideLutIndex = lutIndex + 1; overrideLutIndex < LookModificationSettings::MaxBlendLuts; overrideLutIndex++)
-                                    {
-                                        weight *= one_over[overrideLutIndex];
-                                    }
-                                    m_weights[0] += weight;
-                                }
-                                // Then compute the weights for the LUTs
-                                for (int weightIndex = 0; weightIndex < LookModificationSettings::MaxBlendLuts; weightIndex++)
-                                {
-                                    m_weights[weightIndex + 1] = intensity[weightIndex] * over[weightIndex];
-                                    for (int lutIndex = weightIndex + 1; lutIndex < LookModificationSettings::MaxBlendLuts; lutIndex++)
-                                    {
-                                        m_weights[weightIndex + 1] *= one_over[lutIndex];
-                                    }
-                                }
-                            }
-
-                            // If the number of source LUTs have changed, the shader variant will need to be updated
-                            if (m_numSourceLuts != current)
-                            {
-                                m_numSourceLuts = current;
-                                m_needToUpdateShaderVariant = true;
-                            }
+                            return settings;
                         }
                     }
                 }
             }
+            return nullptr;
         }
     }   // namespace Render
 }   // namespace AZ
diff --git a/Gems/Atom/Feature/Common/Code/Source/PostProcessing/BlendColorGradingLutsPass.h b/Gems/Atom/Feature/Common/Code/Source/PostProcessing/BlendColorGradingLutsPass.h
index d0e6aad4aa..7b37d2c4ec 100644
--- a/Gems/Atom/Feature/Common/Code/Source/PostProcessing/BlendColorGradingLutsPass.h
+++ b/Gems/Atom/Feature/Common/Code/Source/PostProcessing/BlendColorGradingLutsPass.h
@@ -47,6 +47,7 @@ namespace AZ
             static RPI::Ptr<BlendColorGradingLutsPass> Create(const RPI::PassDescriptor& descriptor);
 
             void SetShaperParameters(const ShaperParams& shaperParams);
+            AZStd::optional<ShaperParams> GetCommonShaperParams() const;
 
         private:
             explicit BlendColorGradingLutsPass(const RPI::PassDescriptor& descriptor);
@@ -66,6 +67,7 @@ namespace AZ
             void ReleaseLutImage();
 
             void CheckLutBlendSettings();
+            LookModificationSettings* GetLookModificationSettings() const;
 
             bool m_resourcesInitialized = false;
 
@@ -111,8 +113,6 @@ namespace AZ
             AZStd::array<u32, 3> m_blendedLutDimensions;
 
             float m_weights[LookModificationSettings::MaxBlendLuts + 1]; // The first index is reserved for the weight of the non color graded value
-            Data::Asset<RPI::AnyAsset> m_colorGradingLutAssets[LookModificationSettings::MaxBlendLuts];
-            ShaperPresetType m_colorGradingShaperPresets[LookModificationSettings::MaxBlendLuts];
             Render::ShaperParams m_colorGradingShaperParams[LookModificationSettings::MaxBlendLuts];
             Render::DisplayMapperAssetLut m_colorGradingLuts[LookModificationSettings::MaxBlendLuts];
 
diff --git a/Gems/Atom/Feature/Common/Code/Source/PostProcessing/LookModificationCompositePass.cpp b/Gems/Atom/Feature/Common/Code/Source/PostProcessing/LookModificationCompositePass.cpp
index 40f8f8355d..85c45de96b 100644
--- a/Gems/Atom/Feature/Common/Code/Source/PostProcessing/LookModificationCompositePass.cpp
+++ b/Gems/Atom/Feature/Common/Code/Source/PostProcessing/LookModificationCompositePass.cpp
@@ -9,11 +9,15 @@
 #include <Atom/RPI.Public/RenderPipeline.h>
 #include <Atom/RPI.Public/View.h>
 #include <Atom/RPI.Public/Scene.h>
+#include <Atom/RPI.Public/Pass/PassFilter.h>
+#include <Atom/RPI.Public/Pass/PassSystem.h>
 #include <Atom/RPI.Public/Shader/ShaderVariant.h>
 
 #include <Atom/RHI/FrameScheduler.h>
 #include <Atom/RHI/PipelineState.h>
 
+#include <AzCore/Console/Console.h>
+
 #include <PostProcessing/LookModificationCompositePass.h>
 #include <PostProcess/PostProcessFeatureProcessor.h>
 #include <PostProcess/ExposureControl/ExposureControlSettings.h>
@@ -22,6 +26,22 @@ namespace AZ
 {
     namespace Render
     {
+        AZ_CVAR(uint8_t,
+            r_lutSampleQuality,
+            0,
+            [](const uint8_t& value)
+            {
+                auto passes = RPI::PassSystem::Get()->FindPasses(RPI::PassClassFilter<LookModificationCompositePass>());
+                for (auto* pass : passes)
+                {
+                    LookModificationCompositePass* lookModPass = azrtti_cast<LookModificationCompositePass*>(pass);
+                    lookModPass->SetSampleQuality(LookModificationCompositePass::SampleQuality(value));
+                }
+            },
+            ConsoleFunctorFlags::Null,
+            "This can be increased to deal with particularly tricky luts. Range (0-2). 0 (default) - Standard linear sampling. 1 - 7 tap b-spline sampling. 2 - 19 tap b-spline sampling."
+        );
+        
         RPI::Ptr<LookModificationCompositePass> LookModificationCompositePass::Create(const RPI::PassDescriptor& descriptor)
         {
             RPI::Ptr<LookModificationCompositePass> pass = aznew LookModificationCompositePass(descriptor);
@@ -30,8 +50,6 @@ namespace AZ
 
         LookModificationCompositePass::LookModificationCompositePass(const RPI::PassDescriptor& descriptor)
             : AZ::RPI::FullscreenTrianglePass(descriptor)
-            , m_exposureShaderVariantOptionName(ExposureShaderVariantOptionName)
-            , m_colorGradingShaderVariantOptionName(ColorGradingShaderVariantOptionName)
         {
         }
 
@@ -60,19 +78,38 @@ namespace AZ
         {
             AZ_Assert(m_shader != nullptr, "LookModificationCompositePass %s has a null shader when calling InitializeShaderVariant.", GetPathName().GetCStr());
 
-            AZStd::vector<AZ::Name> exposureVariationTypes = { AZ::Name("true"), AZ::Name("false") };
-            AZStd::vector<AZ::Name> colorGradingVariationTypes = { AZ::Name("true"), AZ::Name("false") };
+            struct OptionSettings
+            {
+                AZ::Name m_enableExposureControl;
+                AZ::Name m_enableColorGrading;
+                RPI::ShaderOptionValue m_lutSampleQuality;
 
-            auto exposureVariationTypeCount = exposureVariationTypes.size();
-            auto totalVariationCount = exposureVariationTypes.size() * colorGradingVariationTypes.size();
+                OptionSettings(const char* enableExposureControl, const char* enableColorGrading, SampleQuality sampleQuality)
+                    : m_enableExposureControl(Name(enableExposureControl))
+                    , m_enableColorGrading(Name(enableColorGrading))
+                    , m_lutSampleQuality(RPI::ShaderOptionValue(sampleQuality))
+                {}
+            };
+
+            AZStd::vector<OptionSettings> options =
+            {
+                { "false", "false", SampleQuality::Linear },
+                { "true", "false", SampleQuality::Linear },
+                { "false", "true", SampleQuality::Linear },
+                { "false", "true", SampleQuality::BSpline7Tap },
+                { "false", "true", SampleQuality::BSpline19Tap },
+                { "true", "true", SampleQuality::Linear },
+                { "true", "true", SampleQuality::BSpline7Tap },
+                { "true", "true", SampleQuality::BSpline19Tap },
+            };
 
             // Caching all pipeline state for each shader variation for performance reason.
-            for (auto shaderVariantIndex = 0; shaderVariantIndex < totalVariationCount; ++shaderVariantIndex)
+            for (auto shaderVariantIndex = 0; shaderVariantIndex < options.size(); ++shaderVariantIndex)
             {
                 auto shaderOption = m_shader->CreateShaderOptionGroup();
-                shaderOption.SetValue(m_exposureShaderVariantOptionName, exposureVariationTypes[shaderVariantIndex % exposureVariationTypeCount]);
-                shaderOption.SetValue(m_colorGradingShaderVariantOptionName, colorGradingVariationTypes[shaderVariantIndex / exposureVariationTypeCount]);
-
+                shaderOption.SetValue(m_exposureShaderVariantOptionName, options.at(shaderVariantIndex).m_enableExposureControl);
+                shaderOption.SetValue(m_colorGradingShaderVariantOptionName, options.at(shaderVariantIndex).m_enableColorGrading);
+                shaderOption.SetValue(m_lutSampleQualityShaderVariantOptionName, options.at(shaderVariantIndex).m_lutSampleQuality);
                 PreloadShaderVariant(m_shader, shaderOption, GetRenderAttachmentConfiguration(), GetMultisampleState());
             }
 
@@ -173,9 +210,9 @@ namespace AZ
                 {
                     m_shaderResourceGroup->SetImageView(m_shaderColorGradingLutImageIndex, m_blendedColorGradingLut.m_lutImageView.get());
 
-                    m_shaderResourceGroup->SetConstant(m_shaderColorGradingShaperTypeIndex, m_colorGradingShaperParams.type);
-                    m_shaderResourceGroup->SetConstant(m_shaderColorGradingShaperBiasIndex, m_colorGradingShaperParams.bias);
-                    m_shaderResourceGroup->SetConstant(m_shaderColorGradingShaperScaleIndex, m_colorGradingShaperParams.scale);
+                    m_shaderResourceGroup->SetConstant(m_shaderColorGradingShaperTypeIndex, m_colorGradingShaperParams.m_type);
+                    m_shaderResourceGroup->SetConstant(m_shaderColorGradingShaperBiasIndex, m_colorGradingShaperParams.m_bias);
+                    m_shaderResourceGroup->SetConstant(m_shaderColorGradingShaperScaleIndex, m_colorGradingShaperParams.m_scale);
                 }
             }
 
@@ -192,7 +229,8 @@ namespace AZ
             // Decide which shader to use.
             shaderOption.SetValue(m_exposureShaderVariantOptionName, m_exposureControlEnabled ? AZ::Name("true") : AZ::Name("false"));
             shaderOption.SetValue(m_colorGradingShaderVariantOptionName, m_colorGradingLutEnabled ? AZ::Name("true") : AZ::Name("false"));
-
+            shaderOption.SetValue(m_lutSampleQualityShaderVariantOptionName, RPI::ShaderOptionValue(m_sampleQuality));
+            
             UpdateShaderVariant(shaderOption);
 
             m_needToUpdateShaderVariant = false;
@@ -218,5 +256,12 @@ namespace AZ
         {
             m_colorGradingShaperParams = shaperParams;
         }
+        
+        void LookModificationCompositePass::SetSampleQuality(SampleQuality sampleQuality)
+        {
+            m_sampleQuality = sampleQuality;
+            m_needToUpdateShaderVariant = true;
+        }
+
     }   // namespace Render
 }   // namespace AZ
diff --git a/Gems/Atom/Feature/Common/Code/Source/PostProcessing/LookModificationCompositePass.h b/Gems/Atom/Feature/Common/Code/Source/PostProcessing/LookModificationCompositePass.h
index 49a0e88a54..b269225445 100644
--- a/Gems/Atom/Feature/Common/Code/Source/PostProcessing/LookModificationCompositePass.h
+++ b/Gems/Atom/Feature/Common/Code/Source/PostProcessing/LookModificationCompositePass.h
@@ -30,8 +30,6 @@ namespace AZ
     namespace Render
     {
         static const char* const LookModificationTransformPassTemplateName{ "LookModificationTransformTemplate" };
-        static const char* const ExposureShaderVariantOptionName{ "o_enableExposureControlFeature" };
-        static const char* const ColorGradingShaderVariantOptionName{ "o_enableColorGradingLut" };
 
         /**
          *  The look modification composite pass. If color grading LUTs are enabled, this pass will apply the blended LUT.
@@ -43,6 +41,14 @@ namespace AZ
         public:
             AZ_RTTI(LookModificationCompositePass, "{D7DF3E8A-B642-4D51-ABC2-ADB2B60FCE1D}", AZ::RPI::FullscreenTrianglePass);
             AZ_CLASS_ALLOCATOR(LookModificationCompositePass, SystemAllocator, 0);
+
+            enum class SampleQuality : uint8_t
+            {
+                Linear = 0,
+                BSpline7Tap = 1,
+                BSpline19Tap = 2,
+            };
+
             virtual ~LookModificationCompositePass() = default;
 
             //! Creates a LookModificationPass
@@ -54,6 +60,8 @@ namespace AZ
             //! Set shaper parameters
             void SetShaperParameters(const ShaperParams& shaperParams);
 
+            void SetSampleQuality(SampleQuality sampleQuality);
+
         protected:
             LookModificationCompositePass(const RPI::PassDescriptor& descriptor);
             
@@ -76,11 +84,15 @@ namespace AZ
 
             bool m_exposureControlEnabled = false;
             bool m_colorGradingLutEnabled = false;
+            SampleQuality m_sampleQuality = SampleQuality::Linear;
+
             Render::DisplayMapperLut m_blendedColorGradingLut;
             Render::ShaperParams m_colorGradingShaperParams;
 
-            const AZ::Name m_exposureShaderVariantOptionName;
-            const AZ::Name m_colorGradingShaderVariantOptionName;
+            const AZ::Name m_exposureShaderVariantOptionName{ "o_enableExposureControlFeature" };
+            const AZ::Name m_colorGradingShaderVariantOptionName{ "o_enableColorGradingLut" };
+            const AZ::Name m_lutSampleQualityShaderVariantOptionName{ "o_lutSampleQuality" };
+
             bool m_needToUpdateShaderVariant = true;
 
             RHI::ShaderInputNameIndex m_shaderColorGradingLutImageIndex = "m_gradingLut";
diff --git a/Gems/Atom/Feature/Common/Code/Source/PostProcessing/LookModificationTransformPass.cpp b/Gems/Atom/Feature/Common/Code/Source/PostProcessing/LookModificationTransformPass.cpp
index cde7d6586b..e33a63a4bb 100644
--- a/Gems/Atom/Feature/Common/Code/Source/PostProcessing/LookModificationTransformPass.cpp
+++ b/Gems/Atom/Feature/Common/Code/Source/PostProcessing/LookModificationTransformPass.cpp
@@ -47,29 +47,32 @@ namespace AZ
                 swapChainFormat = m_swapChainAttachmentBinding->m_attachment->GetTransientImageDescriptor().m_imageDescriptor.m_format;
             }
 
-            if (m_displayBufferFormat != swapChainFormat)
+            // Update the children passes
+            RPI::Ptr<BlendColorGradingLutsPass> blendPass = FindChildPass<BlendColorGradingLutsPass>();
+            if (blendPass)
             {
-                m_displayBufferFormat = swapChainFormat;
-                m_outputDeviceTransformType = AcesDisplayMapperFeatureProcessor::GetOutputDeviceTransformType(m_displayBufferFormat);
-                m_shaperParams = GetAcesShaperParameters(m_outputDeviceTransformType);
-
-                // Update the children passes
-                for (const AZ::RPI::Ptr<Pass>& child : m_children)
+                auto commonShaperParams = blendPass->GetCommonShaperParams();
+                if (commonShaperParams)
                 {
-                    BlendColorGradingLutsPass* blendPass = azrtti_cast<BlendColorGradingLutsPass*>(child.get());
-                    if (blendPass)
-                    {
-                        blendPass->SetShaperParameters(m_shaperParams);
-                        continue;
-                    }
-                    LookModificationCompositePass* compositePass = azrtti_cast<LookModificationCompositePass*>(child.get());
-                    if (compositePass)
-                    {
-                        compositePass->SetShaperParameters(m_shaperParams);
-                        continue;
-                    }
+                    m_shaperParams = *commonShaperParams;
+                }
+                else
+                {
+                    // Mix of shapers used, so shape them based on the output transform type.
+                    m_displayBufferFormat = swapChainFormat;
+                    m_outputDeviceTransformType = AcesDisplayMapperFeatureProcessor::GetOutputDeviceTransformType(m_displayBufferFormat);
+                    m_shaperParams = GetAcesShaperParameters(m_outputDeviceTransformType);
+                }
+
+                blendPass->SetShaperParameters(m_shaperParams);
+                    
+                RPI::Ptr<LookModificationCompositePass> compositePass = FindChildPass<LookModificationCompositePass>();
+                if (compositePass)
+                {
+                    compositePass->SetShaperParameters(m_shaperParams);
                 }
             }
+
             ParentPass::FrameBeginInternal(params);
         }
     }   // namespace Render
diff --git a/Gems/Atom/RPI/Code/Include/Atom/RPI.Public/Pass/ParentPass.h b/Gems/Atom/RPI/Code/Include/Atom/RPI.Public/Pass/ParentPass.h
index 7e341d43c3..36994ec03b 100644
--- a/Gems/Atom/RPI/Code/Include/Atom/RPI.Public/Pass/ParentPass.h
+++ b/Gems/Atom/RPI/Code/Include/Atom/RPI.Public/Pass/ParentPass.h
@@ -64,6 +64,9 @@ namespace AZ
 
             //! Find a child pass with a matching name and returns it. Return nullptr if none found.
             Ptr<Pass> FindChildPass(const Name& passName) const;
+            
+            template<typename PassType>
+            Ptr<PassType> FindChildPass() const;
 
             //! Searches the tree for the first pass that has same pass name (Depth-first search). Return nullptr if none found.
             Ptr<Pass> FindPassByNameRecursive(const Name& passName) const;
@@ -132,5 +135,20 @@ namespace AZ
             // Generates child passes from source PassTemplate
             void CreatePassesFromTemplate();
         };
+
+        template<typename PassType>
+        inline Ptr<PassType> ParentPass::FindChildPass() const
+        {
+            for (const Ptr<Pass>& child : m_children)
+            {
+                PassType* pass = azrtti_cast<PassType*>(child.get());
+                if (pass)
+                {
+                    return pass;
+                }
+            }
+            return {};
+        }
+
     }   // namespace RPI
 }   // namespace AZ
diff --git a/Gems/AtomLyIntegration/CommonFeatures/Code/Include/AtomLyIntegration/CommonFeatures/PostProcess/LookModification/LookModificationComponentConfig.h b/Gems/AtomLyIntegration/CommonFeatures/Code/Include/AtomLyIntegration/CommonFeatures/PostProcess/LookModification/LookModificationComponentConfig.h
index 5ee348a052..0bf9e752a2 100644
--- a/Gems/AtomLyIntegration/CommonFeatures/Code/Include/AtomLyIntegration/CommonFeatures/PostProcess/LookModification/LookModificationComponentConfig.h
+++ b/Gems/AtomLyIntegration/CommonFeatures/Code/Include/AtomLyIntegration/CommonFeatures/PostProcess/LookModification/LookModificationComponentConfig.h
@@ -39,6 +39,11 @@ namespace AZ
             void CopySettingsTo(LookModificationSettingsInterface* settings);
 
             bool ArePropertiesReadOnly() const { return !m_enabled; }
+
+            bool IsUsingCustomShaper() const {
+                return m_shaperPresetType == ShaperPresetType::LinearCustomRange
+                    || m_shaperPresetType == ShaperPresetType::Log2CustomRange;
+            }
         };
     }
 }
diff --git a/Gems/AtomLyIntegration/CommonFeatures/Code/Source/PostProcess/LookModification/EditorLookModificationComponent.cpp b/Gems/AtomLyIntegration/CommonFeatures/Code/Source/PostProcess/LookModification/EditorLookModificationComponent.cpp
index a7dfb76e95..310762863a 100644
--- a/Gems/AtomLyIntegration/CommonFeatures/Code/Source/PostProcess/LookModification/EditorLookModificationComponent.cpp
+++ b/Gems/AtomLyIntegration/CommonFeatures/Code/Source/PostProcess/LookModification/EditorLookModificationComponent.cpp
@@ -48,33 +48,44 @@ namespace AZ
                             &LookModificationComponentConfig::m_enabled,
                             "Enable look modification",
                             "Enable look modification.")
-                        ->Attribute(Edit::Attributes::ChangeNotify, Edit::PropertyRefreshLevels::ValuesOnly)
-
+                            ->Attribute(Edit::Attributes::ChangeNotify, Edit::PropertyRefreshLevels::ValuesOnly)
                         ->DataElement(AZ::Edit::UIHandlers::Default, &LookModificationComponentConfig::m_colorGradingLut, "Color Grading LUT", "Color grading LUT")
-
                         ->ClassElement(Edit::ClassElements::EditorData, "")
                         ->DataElement(Edit::UIHandlers::ComboBox,
-                            &LookModificationComponentConfig::m_shaperPresetType,
-                            "Shaper Type",
-                            "Shaper Type.")
-                        ->EnumAttribute(ShaperPresetType::None, "None")
-                        ->EnumAttribute(ShaperPresetType::Log2_48_nits, "Log2_48_nits")
-                        ->EnumAttribute(ShaperPresetType::Log2_1000_nits, "Log2_1000_nits")
-                        ->EnumAttribute(ShaperPresetType::Log2_2000_nits, "Log2_2000_nits")
-                        ->EnumAttribute(ShaperPresetType::Log2_4000_nits, "Log2_4000_nits")
-                        ->Attribute(Edit::Attributes::ChangeNotify, Edit::PropertyRefreshLevels::ValuesOnly)
-
+                            &LookModificationComponentConfig::m_shaperPresetType, "Shaper Type", "Shaper Type.")
+                            ->EnumAttribute(ShaperPresetType::None, "None")
+                            ->EnumAttribute(ShaperPresetType::LinearCustomRange, "Linear Custom Range")
+                            ->EnumAttribute(ShaperPresetType::Log2_48Nits, "Log2 48 nits")
+                            ->EnumAttribute(ShaperPresetType::Log2_1000Nits, "Log2 1000 nits")
+                            ->EnumAttribute(ShaperPresetType::Log2_2000Nits, "Log2 2000 nits")
+                            ->EnumAttribute(ShaperPresetType::Log2_4000Nits, "Log2 4000 nits")
+                            ->EnumAttribute(ShaperPresetType::Log2CustomRange, "Log2 Custom Range")
+                            ->EnumAttribute(ShaperPresetType::PqSmpteSt2084, "PQ (SMPTE ST 2084)")
+                            ->Attribute(Edit::Attributes::ChangeNotify, Edit::PropertyRefreshLevels::EntireTree)
+                        ->DataElement(AZ::Edit::UIHandlers::Slider, &LookModificationComponentConfig::m_customMinExposure, "Minimum Exposure", "The minimum exposure this LUT supports. Values smaller than this will be clamped to 0.")
+                            ->Attribute(AZ::Edit::Attributes::Min, -50.0f)
+                            ->Attribute(AZ::Edit::Attributes::Max, 0.0f)
+                            ->Attribute(AZ::Edit::Attributes::SoftMin, -20.0f)
+                            ->Attribute(AZ::Edit::Attributes::SoftMax, 0.0f)
+                            ->Attribute(Edit::Attributes::Visibility, &LookModificationComponentConfig::IsUsingCustomShaper)
+                            ->Attribute(AZ::Edit::Attributes::ChangeNotify, Edit::PropertyRefreshLevels::ValuesOnly)
+                        ->DataElement(AZ::Edit::UIHandlers::Slider, &LookModificationComponentConfig::m_customMaxExposure, "Maximum Exposure", "The maximum exposure this LUT supports. Values larger than this will be clamped.")
+                            ->Attribute(AZ::Edit::Attributes::Min, 0.0f)
+                            ->Attribute(AZ::Edit::Attributes::Max, 50.0f)
+                            ->Attribute(AZ::Edit::Attributes::SoftMin, 0.0f)
+                            ->Attribute(AZ::Edit::Attributes::SoftMax, 20.0f)
+                            ->Attribute(Edit::Attributes::Visibility, &LookModificationComponentConfig::IsUsingCustomShaper)
+                            ->Attribute(AZ::Edit::Attributes::ChangeNotify, Edit::PropertyRefreshLevels::ValuesOnly)
                         ->DataElement(AZ::Edit::UIHandlers::Slider, &LookModificationComponentConfig::m_colorGradingLutIntensity, "LUT Intensity", "Blend intensity of this LUT.")
-                        ->Attribute(AZ::Edit::Attributes::Min, 0.0f)
-                        ->Attribute(AZ::Edit::Attributes::Max, 1.0f)
-                        ->Attribute(AZ::Edit::Attributes::ChangeNotify, Edit::PropertyRefreshLevels::ValuesOnly)
-                        ->Attribute(Edit::Attributes::ReadOnly, &LookModificationComponentConfig::ArePropertiesReadOnly)
-
+                            ->Attribute(AZ::Edit::Attributes::Min, 0.0f)
+                            ->Attribute(AZ::Edit::Attributes::Max, 1.0f)
+                            ->Attribute(AZ::Edit::Attributes::ChangeNotify, Edit::PropertyRefreshLevels::ValuesOnly)
+                            ->Attribute(Edit::Attributes::ReadOnly, &LookModificationComponentConfig::ArePropertiesReadOnly)
                         ->DataElement(AZ::Edit::UIHandlers::Slider, &LookModificationComponentConfig::m_colorGradingLutOverride, "LUT Override", "Blend intensity of this LUT.")
-                        ->Attribute(AZ::Edit::Attributes::Min, 0.0f)
-                        ->Attribute(AZ::Edit::Attributes::Max, 1.0f)
-                        ->Attribute(AZ::Edit::Attributes::ChangeNotify, Edit::PropertyRefreshLevels::ValuesOnly)
-                        ->Attribute(Edit::Attributes::ReadOnly, &LookModificationComponentConfig::ArePropertiesReadOnly)
+                            ->Attribute(AZ::Edit::Attributes::Min, 0.0f)
+                            ->Attribute(AZ::Edit::Attributes::Max, 1.0f)
+                            ->Attribute(AZ::Edit::Attributes::ChangeNotify, Edit::PropertyRefreshLevels::ValuesOnly)
+                            ->Attribute(Edit::Attributes::ReadOnly, &LookModificationComponentConfig::ArePropertiesReadOnly)
 
                         // Overrides
                         ->ClassElement(AZ::Edit::ClassElements::Group, "Overrides")

From d15d40fec667ee0e3190a4904bde0f26eb497a7a Mon Sep 17 00:00:00 2001
From: Jeremy Ong <jcong@amazon.com>
Date: Fri, 13 Aug 2021 01:14:06 -0600
Subject: [PATCH 26/37] Add Windows PIX runtime support

Signed-off-by: Jeremy Ong <jcong@amazon.com>
---
 .gitignore                                    |  1 +
 .../AzCore/AzCore/Debug/Profiler.cpp          | 19 +++++++++++++++++++
 Code/Framework/AzCore/AzCore/Debug/Profiler.h |  5 +----
 Code/Framework/AzCore/CMakeLists.txt          | 10 ++++++++++
 Gems/Atom/RHI/DX12/Code/CMakeLists.txt        |  9 ---------
 .../Source/Platform/Android/PAL_android.cmake |  1 -
 .../Source/Platform/Linux/PAL_linux.cmake     |  1 -
 .../Code/Source/Platform/Mac/PAL_mac.cmake    |  1 -
 .../Source/Platform/Windows/PAL_windows.cmake | 12 ------------
 .../Code/Source/Platform/iOS/PAL_ios.cmake    |  1 -
 .../3rdParty/FindPIX.cmake                    |  9 ++++-----
 .../Platform/Windows/pix_windows.cmake        |  2 +-
 cmake/3rdParty/cmake_files.cmake              |  1 +
 cmake/Platform/Android/PAL_android.cmake      |  2 ++
 cmake/Platform/Linux/PAL_linux.cmake          |  2 ++
 cmake/Platform/Mac/PAL_mac.cmake              |  2 ++
 cmake/Platform/Windows/PAL_windows.cmake      |  2 ++
 cmake/Platform/iOS/PAL_ios.cmake              |  2 ++
 18 files changed, 47 insertions(+), 35 deletions(-)
 rename Gems/Atom/RHI/DX12/3rdParty/Findpix.cmake => cmake/3rdParty/FindPIX.cmake (59%)
 rename {Gems/Atom/RHI/DX12 => cmake}/3rdParty/Platform/Windows/pix_windows.cmake (98%)

diff --git a/.gitignore b/.gitignore
index b73c89b1d9..e41b92498f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,6 +3,7 @@
 .vscode/
 __pycache__
 AssetProcessorTemp/**
+CMakeUserPresets.json
 [Bb]uild/**
 [Oo]ut/**
 [Cc]ache/
diff --git a/Code/Framework/AzCore/AzCore/Debug/Profiler.cpp b/Code/Framework/AzCore/AzCore/Debug/Profiler.cpp
index e6b7a80707..eda7330cfc 100644
--- a/Code/Framework/AzCore/AzCore/Debug/Profiler.cpp
+++ b/Code/Framework/AzCore/AzCore/Debug/Profiler.cpp
@@ -18,6 +18,12 @@
 #include <AzCore/std/functional.h>
 #include <AzCore/Math/Crc.h>
 
+#ifdef USE_PIX
+#include <AzCore/PlatformIncl.h>
+#include <WinPixEventRuntime/pix3.h>
+#endif
+
+
 namespace AZ
 {
     namespace Debug
@@ -495,6 +501,10 @@ namespace AZ
         ProfilerRegister*
         ProfilerRegister::TimerCreateAndStart(const char* systemName, const char* name, ProfilerSection * section, const char* function, int line)
         {
+#if defined(USE_PIX)
+            PIXBeginEvent(PIX_COLOR(0, 0, 1), "%s:%s", name, function);
+#endif
+
             AZStd::chrono::system_clock::time_point start = AZStd::chrono::system_clock::now();
             ProfilerRegister* reg = CreateRegister(systemName, name, function, line, ProfilerRegister::PRT_TIME);
             AZStd::chrono::system_clock::time_point end = AZStd::chrono::system_clock::now();
@@ -537,6 +547,11 @@ namespace AZ
         void ProfilerRegister::TimerStart(ProfilerSection* section)
         {
             ProfilerRegister* reg = this;
+
+#if defined(USE_PIX)
+            PIXBeginEvent(PIX_COLOR(0, 0, 1), "%s:%s", reg->m_name, reg->m_function);
+#endif
+
             if (reg->m_isActive)
             {
                 section->m_register = reg;
@@ -555,6 +570,10 @@ namespace AZ
         //=========================================================================
         void ProfilerRegister::TimerStop()
         {
+#if defined(USE_PIX)
+            PIXEndEvent();
+#endif
+
             AZStd::chrono::system_clock::time_point end = AZStd::chrono::system_clock::now();
             ProfilerSection* section = m_threadData->m_stack.back();
             AZStd::chrono::microseconds elapsedTime = end - section->m_start;
diff --git a/Code/Framework/AzCore/AzCore/Debug/Profiler.h b/Code/Framework/AzCore/AzCore/Debug/Profiler.h
index 243a8da0b0..6dcdcfdddc 100644
--- a/Code/Framework/AzCore/AzCore/Debug/Profiler.h
+++ b/Code/Framework/AzCore/AzCore/Debug/Profiler.h
@@ -5,8 +5,7 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
-#ifndef AZCORE_PROFILER_H
-#define AZCORE_PROFILER_H 1
+#pragma once
 
 #include <AzCore/std/chrono/chrono.h>
 #include <AzCore/std/function/function_fwd.h>
@@ -615,5 +614,3 @@ namespace AZ
     }
 } // namespace AZ
 
-#endif // AZCORE_PROFILER_H
-#pragma once
diff --git a/Code/Framework/AzCore/CMakeLists.txt b/Code/Framework/AzCore/CMakeLists.txt
index ea7cc27af5..ab9596e2b2 100644
--- a/Code/Framework/AzCore/CMakeLists.txt
+++ b/Code/Framework/AzCore/CMakeLists.txt
@@ -19,6 +19,12 @@ if(LY_RAD_TELEMETRY_ENABLED)
     set(AZ_CORE_RADTELEMETRY_BUILD_DEPENDENCIES 3rdParty::RadTelemetry)
 endif()
 
+if(PAL_TRAIT_PROF_PIX_SUPPORTED AND LY_PIX_ENABLED)
+    set(LY_PIX_PATH "${LY_3RDPARTY_PATH}/winpixeventruntime" CACHE PATH "Path to the Windows Pix Event Runtime.")
+    set(AZ_CORE_PIX_BUILD_DEPENDENCIES 3rdParty::pix)
+    set(AZ_CORE_PIX_BUILD_DEFINES "USE_PIX")
+endif()
+
 ly_add_target(
     NAME AzCore STATIC
     NAMESPACE AZ
@@ -45,6 +51,10 @@ ly_add_target(
             3rdParty::zstd
             3rdParty::cityhash
             ${AZ_CORE_RADTELEMETRY_BUILD_DEPENDENCIES}
+            ${AZ_CORE_PIX_BUILD_DEPENDENCIES}
+    COMPILE_DEFINITIONS
+        PUBLIC
+            ${AZ_CORE_PIX_BUILD_DEFINES}
 )
 ly_add_source_properties(
     SOURCES
diff --git a/Gems/Atom/RHI/DX12/Code/CMakeLists.txt b/Gems/Atom/RHI/DX12/Code/CMakeLists.txt
index a16b958c66..8670efa7e6 100644
--- a/Gems/Atom/RHI/DX12/Code/CMakeLists.txt
+++ b/Gems/Atom/RHI/DX12/Code/CMakeLists.txt
@@ -12,10 +12,8 @@ ly_get_list_relative_pal_filename(pal_source_dir ${CMAKE_CURRENT_LIST_DIR}/Sourc
 include(${pal_source_dir}/PAL_${PAL_PLATFORM_NAME_LOWERCASE}.cmake) # PAL_TRAIT_ATOM_RHI_DX12_SUPPORTED
 
 if(PAL_TRAIT_PIX_AVAILABLE)
-    set(USE_PIX_DEFINE "USE_PIX")
     set(PIX_BUILD_DEPENDENCY "3rdParty::pix")
 else()
-    set(USE_PIX_DEFINE "")
     set(PIX_BUILD_DEPENDENCY "")
 endif()
 
@@ -94,9 +92,6 @@ ly_add_target(
             AZ::AzCore
             ${PIX_BUILD_DEPENDENCY}
             Gem::Atom_RHI.Reflect
-    COMPILE_DEFINITIONS 
-        PRIVATE
-            ${USE_PIX_DEFINE}
 )
 
 ly_add_target(
@@ -124,7 +119,6 @@ ly_add_target(
             ${PIX_BUILD_DEPENDENCY}
     COMPILE_DEFINITIONS 
         PRIVATE
-            ${USE_PIX_DEFINE}
             ${USE_NSIGHT_AFTERMATH_DEFINE}
             
 )
@@ -149,9 +143,6 @@ ly_add_target(
             Gem::Atom_RHI_DX12.Reflect
             Gem::Atom_RHI_DX12.Private.Static
             ${PIX_BUILD_DEPENDENCY}
-    COMPILE_DEFINITIONS 
-        PRIVATE
-            ${USE_PIX_DEFINE}
 )
 
 if(PAL_TRAIT_BUILD_HOST_TOOLS)
diff --git a/Gems/Atom/RHI/DX12/Code/Source/Platform/Android/PAL_android.cmake b/Gems/Atom/RHI/DX12/Code/Source/Platform/Android/PAL_android.cmake
index 240ec6941c..8becd70f81 100644
--- a/Gems/Atom/RHI/DX12/Code/Source/Platform/Android/PAL_android.cmake
+++ b/Gems/Atom/RHI/DX12/Code/Source/Platform/Android/PAL_android.cmake
@@ -7,5 +7,4 @@
 #
 
 set(PAL_TRAIT_ATOM_RHI_DX12_SUPPORTED FALSE)
-set(PAL_TRAIT_PIX_AVAILABLE FALSE)
 set(PAL_TRAIT_AFTERMATH_AVAILABLE FALSE)
diff --git a/Gems/Atom/RHI/DX12/Code/Source/Platform/Linux/PAL_linux.cmake b/Gems/Atom/RHI/DX12/Code/Source/Platform/Linux/PAL_linux.cmake
index 240ec6941c..8becd70f81 100644
--- a/Gems/Atom/RHI/DX12/Code/Source/Platform/Linux/PAL_linux.cmake
+++ b/Gems/Atom/RHI/DX12/Code/Source/Platform/Linux/PAL_linux.cmake
@@ -7,5 +7,4 @@
 #
 
 set(PAL_TRAIT_ATOM_RHI_DX12_SUPPORTED FALSE)
-set(PAL_TRAIT_PIX_AVAILABLE FALSE)
 set(PAL_TRAIT_AFTERMATH_AVAILABLE FALSE)
diff --git a/Gems/Atom/RHI/DX12/Code/Source/Platform/Mac/PAL_mac.cmake b/Gems/Atom/RHI/DX12/Code/Source/Platform/Mac/PAL_mac.cmake
index 240ec6941c..8becd70f81 100644
--- a/Gems/Atom/RHI/DX12/Code/Source/Platform/Mac/PAL_mac.cmake
+++ b/Gems/Atom/RHI/DX12/Code/Source/Platform/Mac/PAL_mac.cmake
@@ -7,5 +7,4 @@
 #
 
 set(PAL_TRAIT_ATOM_RHI_DX12_SUPPORTED FALSE)
-set(PAL_TRAIT_PIX_AVAILABLE FALSE)
 set(PAL_TRAIT_AFTERMATH_AVAILABLE FALSE)
diff --git a/Gems/Atom/RHI/DX12/Code/Source/Platform/Windows/PAL_windows.cmake b/Gems/Atom/RHI/DX12/Code/Source/Platform/Windows/PAL_windows.cmake
index a7e4015659..b885e53ec0 100644
--- a/Gems/Atom/RHI/DX12/Code/Source/Platform/Windows/PAL_windows.cmake
+++ b/Gems/Atom/RHI/DX12/Code/Source/Platform/Windows/PAL_windows.cmake
@@ -21,18 +21,6 @@ endif()
 set(PAL_TRAIT_PIX_AVAILABLE FALSE)
 unset(pix3_header CACHE)
 
-file(TO_CMAKE_PATH "$ENV{ATOM_PIX_PATH}" ATOM_PIX_PATH_CMAKE_FORMATTED)
-find_file(pix3_header
-    pix3.h
-    PATHS
-        "${ATOM_PIX_PATH_CMAKE_FORMATTED}/Include/WinPixEventRuntime"
-)
-
-mark_as_advanced(pix3_header)
-if(pix3_header)
-    set(PAL_TRAIT_PIX_AVAILABLE TRUE)
-endif()
-
 set(PAL_TRAIT_AFTERMATH_AVAILABLE FALSE)
 unset(aftermath_header CACHE)
 file(TO_CMAKE_PATH "$ENV{ATOM_AFTERMATH_PATH}" ATOM_AFTERMATH_PATH_CMAKE_FORMATTED)
diff --git a/Gems/Atom/RHI/DX12/Code/Source/Platform/iOS/PAL_ios.cmake b/Gems/Atom/RHI/DX12/Code/Source/Platform/iOS/PAL_ios.cmake
index 240ec6941c..8becd70f81 100644
--- a/Gems/Atom/RHI/DX12/Code/Source/Platform/iOS/PAL_ios.cmake
+++ b/Gems/Atom/RHI/DX12/Code/Source/Platform/iOS/PAL_ios.cmake
@@ -7,5 +7,4 @@
 #
 
 set(PAL_TRAIT_ATOM_RHI_DX12_SUPPORTED FALSE)
-set(PAL_TRAIT_PIX_AVAILABLE FALSE)
 set(PAL_TRAIT_AFTERMATH_AVAILABLE FALSE)
diff --git a/Gems/Atom/RHI/DX12/3rdParty/Findpix.cmake b/cmake/3rdParty/FindPIX.cmake
similarity index 59%
rename from Gems/Atom/RHI/DX12/3rdParty/Findpix.cmake
rename to cmake/3rdParty/FindPIX.cmake
index b8e7118953..4bce14312d 100644
--- a/Gems/Atom/RHI/DX12/3rdParty/Findpix.cmake
+++ b/cmake/3rdParty/FindPIX.cmake
@@ -6,15 +6,14 @@
 #
 #
 
-file(TO_CMAKE_PATH "$ENV{ATOM_PIX_PATH}" ATOM_PIX_PATH_CMAKE_FORMATTED)
+if(LY_PIX_ENABLED)
+    file(TO_CMAKE_PATH "${LY_PIX_PATH}" PIX_PATH)
+    message(STATUS "PIX PATH ${PIX_PATH}")
 
-if(EXISTS "${ATOM_PIX_PATH_CMAKE_FORMATTED}/include/WinPixEventRuntime/pix3.h")
     ly_add_external_target(
         NAME pix
+        3RDPARTY_ROOT_DIRECTORY "${PIX_PATH}"
         VERSION
-        3RDPARTY_ROOT_DIRECTORY ${ATOM_PIX_PATH_CMAKE_FORMATTED}
         INCLUDE_DIRECTORIES include
     )
 endif()
-
-
diff --git a/Gems/Atom/RHI/DX12/3rdParty/Platform/Windows/pix_windows.cmake b/cmake/3rdParty/Platform/Windows/pix_windows.cmake
similarity index 98%
rename from Gems/Atom/RHI/DX12/3rdParty/Platform/Windows/pix_windows.cmake
rename to cmake/3rdParty/Platform/Windows/pix_windows.cmake
index 54d419d1c2..aba65d9627 100644
--- a/Gems/Atom/RHI/DX12/3rdParty/Platform/Windows/pix_windows.cmake
+++ b/cmake/3rdParty/Platform/Windows/pix_windows.cmake
@@ -11,4 +11,4 @@ if(LY_MONOLITHIC_GAME)
 else()
     set(PIX_LIBS ${BASE_PATH}/bin/x64/WinPixEventRuntime.lib)
     set(PIX_RUNTIME_DEPENDENCIES ${BASE_PATH}/bin/x64/WinPixEventRuntime.dll)
-endif()
+endif()
\ No newline at end of file
diff --git a/cmake/3rdParty/cmake_files.cmake b/cmake/3rdParty/cmake_files.cmake
index 99e83da4fe..cf56031db6 100644
--- a/cmake/3rdParty/cmake_files.cmake
+++ b/cmake/3rdParty/cmake_files.cmake
@@ -9,6 +9,7 @@
 set(FILES
     BuiltInPackages.cmake
     FindOpenGLInterface.cmake
+    FindPIX.cmake
     FindRadTelemetry.cmake
     FindVkValidation.cmake
     FindWwise.cmake
diff --git a/cmake/Platform/Android/PAL_android.cmake b/cmake/Platform/Android/PAL_android.cmake
index 8a7c6406b7..1ef36b1af6 100644
--- a/cmake/Platform/Android/PAL_android.cmake
+++ b/cmake/Platform/Android/PAL_android.cmake
@@ -18,6 +18,8 @@ ly_set(PAL_TRAIT_BUILD_UNITY_EXCLUDE_EXTENSIONS)
 ly_set(PAL_TRAIT_BUILD_EXCLUDE_ALL_TEST_RUNS_FROM_IDE TRUE)
 ly_set(PAL_TRAIT_BUILD_CPACK_SUPPORTED FALSE)
 
+ly_set(PAL_TRAIT_PROF_PIX_SUPPORTED FALSE)
+
 # Test library support
 ly_set(PAL_TRAIT_TEST_GOOGLE_TEST_SUPPORTED FALSE)
 ly_set(PAL_TRAIT_TEST_GOOGLE_BENCHMARK_SUPPORTED FALSE)
diff --git a/cmake/Platform/Linux/PAL_linux.cmake b/cmake/Platform/Linux/PAL_linux.cmake
index c137538ac0..528bb5794c 100644
--- a/cmake/Platform/Linux/PAL_linux.cmake
+++ b/cmake/Platform/Linux/PAL_linux.cmake
@@ -18,6 +18,8 @@ ly_set(PAL_TRAIT_BUILD_UNITY_EXCLUDE_EXTENSIONS)
 ly_set(PAL_TRAIT_BUILD_EXCLUDE_ALL_TEST_RUNS_FROM_IDE FALSE)
 ly_set(PAL_TRAIT_BUILD_CPACK_SUPPORTED FALSE)
 
+ly_set(PAL_TRAIT_PROF_PIX_SUPPORTED FALSE)
+
 # Test library support
 ly_set(PAL_TRAIT_TEST_GOOGLE_TEST_SUPPORTED TRUE)
 ly_set(PAL_TRAIT_TEST_GOOGLE_BENCHMARK_SUPPORTED TRUE)
diff --git a/cmake/Platform/Mac/PAL_mac.cmake b/cmake/Platform/Mac/PAL_mac.cmake
index 7ddb4a1b5e..b415daf44a 100644
--- a/cmake/Platform/Mac/PAL_mac.cmake
+++ b/cmake/Platform/Mac/PAL_mac.cmake
@@ -18,6 +18,8 @@ ly_set(PAL_TRAIT_BUILD_UNITY_EXCLUDE_EXTENSIONS ".mm")
 ly_set(PAL_TRAIT_BUILD_EXCLUDE_ALL_TEST_RUNS_FROM_IDE FALSE)
 ly_set(PAL_TRAIT_BUILD_CPACK_SUPPORTED FALSE)
 
+ly_set(PAL_TRAIT_PROF_PIX_SUPPORTED FALSE)
+
 # Test library support
 ly_set(PAL_TRAIT_TEST_GOOGLE_TEST_SUPPORTED TRUE)
 ly_set(PAL_TRAIT_TEST_GOOGLE_BENCHMARK_SUPPORTED TRUE)
diff --git a/cmake/Platform/Windows/PAL_windows.cmake b/cmake/Platform/Windows/PAL_windows.cmake
index f4fa2e676a..f329425cd3 100644
--- a/cmake/Platform/Windows/PAL_windows.cmake
+++ b/cmake/Platform/Windows/PAL_windows.cmake
@@ -18,6 +18,8 @@ ly_set(PAL_TRAIT_BUILD_UNITY_EXCLUDE_EXTENSIONS)
 ly_set(PAL_TRAIT_BUILD_EXCLUDE_ALL_TEST_RUNS_FROM_IDE FALSE)
 ly_set(PAL_TRAIT_BUILD_CPACK_SUPPORTED TRUE)
 
+ly_set(PAL_TRAIT_PROF_PIX_SUPPORTED TRUE)
+
 # Test library support
 ly_set(PAL_TRAIT_TEST_GOOGLE_TEST_SUPPORTED TRUE)
 ly_set(PAL_TRAIT_TEST_GOOGLE_BENCHMARK_SUPPORTED TRUE)
diff --git a/cmake/Platform/iOS/PAL_ios.cmake b/cmake/Platform/iOS/PAL_ios.cmake
index 3da4a13ed2..e1c4b6d37e 100644
--- a/cmake/Platform/iOS/PAL_ios.cmake
+++ b/cmake/Platform/iOS/PAL_ios.cmake
@@ -18,6 +18,8 @@ ly_set(PAL_TRAIT_BUILD_UNITY_EXCLUDE_EXTENSIONS ".mm")
 ly_set(PAL_TRAIT_BUILD_EXCLUDE_ALL_TEST_RUNS_FROM_IDE TRUE)
 ly_set(PAL_TRAIT_BUILD_CPACK_SUPPORTED FALSE)
 
+ly_set(PAL_TRAIT_PROF_PIX_SUPPORTED FALSE)
+
 # Test library support
 ly_set(PAL_TRAIT_TEST_GOOGLE_TEST_SUPPORTED FALSE)
 ly_set(PAL_TRAIT_TEST_GOOGLE_BENCHMARK_SUPPORTED FALSE)

From df9b4d4a2fb197c551b1db66f5befd716797c614 Mon Sep 17 00:00:00 2001
From: Jeremy Ong <jcong@amazon.com>
Date: Tue, 17 Aug 2021 12:10:57 -0600
Subject: [PATCH 27/37] Deprecate profiler categories based on global enum

(to be supplanted by registered budgets in the future)

Signed-off-by: Jeremy Ong <jcong@amazon.com>
---
 Code/Editor/CryEditDoc.cpp                    |  10 +-
 Code/Editor/EditorViewportWidget.cpp          |   4 +-
 Code/Editor/Objects/AxisGizmo.cpp             |   2 +-
 Code/Editor/Objects/BaseObject.cpp            |   6 +-
 Code/Editor/Objects/EntityObject.cpp          |   2 +-
 Code/Editor/Objects/ObjectManager.cpp         |  38 +-
 .../Objects/ObjectManagerLegacyUndo.cpp       |   8 +-
 .../Objects/ComponentEntityObject.cpp         |   6 +-
 .../SandboxIntegration.cpp                    |  14 +-
 .../UI/Outliner/OutlinerListModel.cpp         |  34 +-
 .../UI/Outliner/OutlinerWidget.cpp            |  24 +-
 .../AssetImporterDocument.cpp                 |   2 +-
 .../ImporterRootDisplay.cpp                   |   4 +-
 .../SceneSerializationHandler.cpp             |   3 +-
 Code/Editor/Viewport.cpp                      |   4 +-
 .../AzCore/AzCore/Android/APKFileHandler.h    |   4 +-
 .../AzCore/AzCore/Asset/AssetDataStream.cpp   |  20 +-
 .../AzCore/AzCore/Asset/AssetManager.cpp      |  38 +-
 Code/Framework/AzCore/AzCore/AzCoreModule.cpp |   8 -
 .../AzCore/Component/ComponentApplication.cpp |  10 +-
 .../AzCore/AzCore/Component/Entity.cpp        |   6 +-
 .../AzCore/AzCore/Component/EntityUtils.cpp   |   2 +-
 .../AzCore/AzCore/Component/EntityUtils.h     |   6 +-
 .../AzCore/AzCore/Debug/EventTrace.h          |   4 +-
 .../AzCore/AzCore/Debug/MemoryProfiler.h      |  16 +
 .../AzCore/AzCore/Debug/Profiler.cpp          |  24 +-
 Code/Framework/AzCore/AzCore/Debug/Profiler.h | 339 ++++--------------
 Code/Framework/AzCore/AzCore/IO/FileIO.cpp    |   9 +-
 .../AzCore/AzCore/IO/Streamer/BlockCache.cpp  |   5 +-
 .../IO/Streamer/FullFileDecompressor.cpp      |   9 +-
 .../AzCore/IO/Streamer/ReadSplitter.cpp       |   5 +-
 .../AzCore/AzCore/IO/Streamer/Scheduler.cpp   |  29 +-
 .../AzCore/AzCore/IO/Streamer/Statistics.cpp  |   2 +-
 .../AzCore/IO/Streamer/StorageDrive.cpp       |   8 +-
 .../AzCore/AzCore/IO/Streamer/Streamer.cpp    |   7 +-
 .../AzCore/IO/Streamer/StreamerContext.cpp    |   6 +-
 .../Framework/AzCore/AzCore/IO/SystemFile.cpp |  43 ---
 .../AzCore/Jobs/Internal/JobManagerBase.cpp   |   4 +-
 .../Jobs/Internal/JobManagerWorkStealing.cpp  |   8 +-
 .../AzCore/AzCore/Jobs/JobCompletion.h        |   2 +-
 .../AzCore/AzCore/Jobs/LegacyJobExecutor.h    |   2 +-
 .../AzCore/Memory/AllocationRecords.cpp       |   1 +
 .../AzCore/Memory/SimpleSchemaAllocator.h     |  12 +-
 .../AzCore/AzCore/Memory/SystemAllocator.cpp  |   8 +-
 .../AzCore/Script/ScriptSystemComponent.cpp   |   2 +-
 .../AzCore/AzCore/Serialization/DataPatch.cpp |  26 +-
 .../AzCore/Serialization/ObjectStream.cpp     |   4 +-
 .../Serialization/SerializationUtils.cpp      |  12 +-
 .../AzCore/AzCore/Slice/SliceComponent.cpp    |  60 ++--
 .../Statistics/StatisticalProfilerProxy.h     |  10 +-
 .../Statistics/TimeDataStatisticsManager.h    |   2 +-
 .../AzCore/AzCore/azcore_files.cmake          |   5 +-
 .../AzCore/AzCore/std/parallel/spin_mutex.h   |   3 -
 .../Common/RadTelemetry/ProfileTelemetry.h    |  18 +-
 .../AzCore/IO/SystemFile_UnixLike.cpp         |   3 +-
 .../IO/Streamer/StorageDrive_Windows.cpp      |  18 +-
 Code/Framework/AzCore/Tests/Components.cpp    |   7 +-
 Code/Framework/AzCore/Tests/Debug.cpp         | 270 --------------
 .../AzCore/Tests/StatisticalProfiler.cpp      |  44 +--
 .../AzCore/Tests/TimeDataStatistics.cpp       |   6 +-
 .../AzCore/Tests/azcoretests_files.cmake      |   1 -
 .../AzFramework/Application/Application.cpp   |  11 +-
 .../AzFramework/Archive/Archive.cpp           |  19 +-
 .../AzFramework/Entity/EntityContext.cpp      |   4 +-
 .../Entity/SliceEntityOwnershipService.cpp    |  14 +-
 .../AzFramework/IO/RemoteStorageDrive.cpp     |   6 +-
 .../AzFramework/Script/ScriptComponent.cpp    |   8 +-
 .../TargetManagementComponent.cpp             |  10 +-
 .../EntityVisibilityBoundsUnionSystem.cpp     |  11 +-
 .../Visibility/EntityVisibilityQuery.cpp      |   2 +-
 .../Platform/Android/AzTest_Traits_Android.h  |   1 -
 .../Application/ToolsApplication.cpp          |  30 +-
 .../Commands/EntityStateCommand.cpp           |   8 +-
 .../Commands/PreemptiveUndoCache.cpp          |   2 +-
 .../Entity/EditorEntityContextComponent.cpp   |  24 +-
 .../Entity/EditorEntityHelpers.cpp            |  42 +--
 .../Entity/EditorEntityModel.cpp              |  70 ++--
 .../Entity/EditorEntitySortComponent.cpp      |  10 +-
 .../SliceEditorEntityOwnershipService.cpp     |  32 +-
 .../Manipulators/BaseManipulator.cpp          |  22 +-
 .../Manipulators/EditorVertexSelection.cpp    |  42 +--
 .../Manipulators/ManipulatorManager.cpp       |  12 +-
 .../Prefab/PrefabPublicHandler.cpp            |  16 +-
 .../Prefab/PrefabUndoCache.cpp                |   3 +-
 .../Slice/SliceCompilation.cpp                |   4 +-
 .../Slice/SliceTransaction.cpp                |  38 +-
 .../AzToolsFramework/Slice/SliceUtilities.cpp |  42 +--
 .../ToolsComponents/EditorLayerComponent.cpp  |  10 +-
 .../EditorSelectionAccentSystemComponent.cpp  |   8 +-
 .../ComponentPalette/ComponentPaletteUtil.cpp |   4 +-
 .../ComponentPaletteWidget.cpp                |   4 +-
 .../UI/Outliner/EntityOutlinerListModel.cpp   |  34 +-
 .../UI/Outliner/EntityOutlinerWidget.cpp      |  24 +-
 .../UI/Prefab/PrefabIntegrationManager.cpp    |  10 +-
 .../UI/PropertyEditor/ComponentEditor.cpp     |   2 +-
 .../PropertyEditor/EntityPropertyEditor.cpp   |  26 +-
 .../PropertyEditor/InstanceDataHierarchy.cpp  |  14 +-
 .../UI/PropertyEditor/PropertyEditorAPI.h     |   2 +-
 .../PropertyEditorAPI_Internals.h             |   3 +-
 .../UI/PropertyEditor/PropertyEditorApi.cpp   |   2 +-
 .../UI/PropertyEditor/PropertyRowWidget.cpp   |   2 +-
 .../ReflectedPropertyEditor.cpp               |   8 +-
 .../Viewport/EditorContextMenu.cpp            |   2 +-
 .../ViewportSelection/EditorBoxSelect.cpp     |   4 +-
 .../ViewportSelection/EditorHelpers.cpp       |   8 +-
 .../EditorInteractionSystemComponent.cpp      |   2 +-
 .../EditorPickEntitySelection.cpp             |   2 +-
 .../ViewportSelection/EditorSelectionUtil.cpp |   6 +-
 .../EditorTransformComponentSelection.cpp     | 140 ++++----
 .../EditorVisibleEntityDataCache.cpp          |  16 +-
 .../GridMate/GridMate/Replica/Replica.cpp     |  34 +-
 .../GridMate/Replica/ReplicaChunk.cpp         |  22 +-
 .../GridMate/GridMate/Replica/ReplicaMgr.cpp  |  10 +-
 .../GridMate/GridMate/Replica/ReplicaMgr.h    |   2 +-
 .../GridMate/GridMate/Replica/ReplicaUtils.h  |   2 +-
 Code/Legacy/CryCommon/FrameProfiler.h         |  19 +-
 Code/Legacy/CryCommon/ISystem.h               |   8 +-
 Code/Legacy/CryCommon/LegacyAllocator.h       |   8 +-
 Code/Legacy/CryCommon/platform_impl.cpp       |   2 +-
 Code/Legacy/CrySystem/System.cpp              |   2 +-
 .../SceneUI/SceneWidgets/ManifestWidget.cpp   |   4 +-
 .../SceneWidgets/ManifestWidgetPage.cpp       |   4 +-
 .../Standalone/Source/Driller/AreaChart.cpp   |   8 +-
 .../Source/Driller/Replica/BaseDetailView.h   |   4 +-
 .../Driller/Replica/ReplicaDataView.cpp       |   2 +-
 .../Atom/ImageProcessing/ImageProcessingBus.h |   1 +
 .../Code/Source/ImageBuilderComponent.h       |   1 +
 .../Code/Source/AuxGeom/AuxGeomDrawQueue.cpp  |   4 +-
 .../Source/AuxGeom/FixedShapeProcessor.cpp    |   2 +-
 .../DecalTextureArrayFeatureProcessor.cpp     |   8 +-
 .../DiffuseProbeGridFeatureProcessor.cpp      |   4 +-
 .../Common/Code/Source/ImGui/ImGuiPass.cpp    |   4 +-
 .../Code/Source/Mesh/MeshFeatureProcessor.cpp |  20 +-
 .../ReflectionProbeFeatureProcessor.cpp       |   4 +-
 .../SkinnedMeshFeatureProcessor.cpp           |   8 +-
 .../SkinnedMesh/SkinnedMeshInputBuffers.cpp   |   2 +-
 .../RHI/Code/Source/RHI/AsyncWorkQueue.cpp    |   4 +-
 .../Atom/RHI/Code/Source/RHI/CommandQueue.cpp |   4 +-
 Gems/Atom/RHI/Code/Source/RHI/Fence.cpp       |   2 +-
 .../RHI/Code/Source/RHI/FrameScheduler.cpp    |  24 +-
 .../Code/Source/RHI/PipelineStateCache.cpp    |   2 +-
 Gems/Atom/RHI/Code/Source/RHI/RHISystem.cpp   |   4 +-
 .../DX12/Code/Source/RHI/AsyncUploadQueue.cpp |  24 +-
 .../DX12/Code/Source/RHI/CommandListBase.cpp  |   4 +-
 .../DX12/Code/Source/RHI/CommandListBase.h    |   6 +-
 .../RHI/DX12/Code/Source/RHI/CommandQueue.cpp |   8 +-
 .../Code/Source/RHI/CommandQueueContext.cpp   |  10 +-
 Gems/Atom/RHI/DX12/Code/Source/RHI/Fence.cpp  |   2 +-
 Gems/Atom/RHI/DX12/Code/Source/RHI/Fence.h    |   3 +-
 .../Code/Source/RHI/StreamingImagePool.cpp    |   2 +-
 .../Metal/Code/Source/RHI/CommandQueue.cpp    |   2 +-
 .../Code/Source/RHI/CommandQueueContext.cpp   |   4 +-
 .../Code/Source/RHI/AsyncUploadQueue.cpp      |  16 +-
 .../Vulkan/Code/Source/RHI/CommandQueue.cpp   |   2 +-
 .../Code/Source/RHI/CommandQueueContext.cpp   |   6 +-
 .../RPI/Code/Source/RPI.Public/Culling.cpp    |  14 +-
 .../Source/RPI.Public/Material/Material.cpp   |   4 +-
 .../Code/Source/RPI.Public/MeshDrawPacket.cpp |   6 +-
 .../Code/Source/RPI.Public/Model/Model.cpp    |  10 +-
 .../Code/Source/RPI.Public/Model/ModelLod.cpp |   4 +-
 .../Source/RPI.Public/Model/ModelLodUtils.cpp |   2 +-
 .../Source/RPI.Public/Pass/PassSystem.cpp     |   8 +-
 .../Source/RPI.Public/Pass/RasterPass.cpp     |   4 +-
 .../RPI/Code/Source/RPI.Public/RPISystem.cpp  |   2 +-
 .../Code/Source/RPI.Public/RenderPipeline.cpp |   2 +-
 .../Atom/RPI/Code/Source/RPI.Public/Scene.cpp |  10 +-
 .../Shader/Metrics/ShaderMetricsSystem.cpp    |   2 +-
 .../Code/Source/RPI.Public/Shader/Shader.cpp  |   6 +-
 Gems/Atom/RPI/Code/Source/RPI.Public/View.cpp |   2 +-
 .../Source/RPI.Reflect/Model/ModelAsset.cpp   |   2 +-
 .../Source/RPI.Reflect/Shader/ShaderAsset.cpp |   4 +-
 .../Shader/ShaderVariantTreeAsset.cpp         |   2 +-
 .../Include/Atom/Utils/StableDynamicArray.h   |   1 +
 .../SurfaceData/SurfaceDataMeshComponent.cpp  |   4 +-
 .../Source/Engine/AudioSystemImpl_wwise.cpp   |   4 +-
 .../Source/Engine/FileIOHandler_wwise.cpp     |   2 +-
 Gems/AudioSystem/Code/Source/Engine/ATL.cpp   |   4 +-
 .../Code/Source/Engine/ATLComponents.cpp      |   7 +-
 .../AudioSystem/Code/Source/Engine/ATLUtils.h |   1 +
 .../Code/Source/Engine/AudioSystem.cpp        |  16 +-
 .../Code/Source/Engine/FileCacheManager.cpp   |  11 +-
 .../Components/BlastFamilyComponent.cpp       |  14 +-
 .../Components/BlastSystemComponent.cpp       |  18 +-
 .../Editor/EditorBlastFamilyComponent.cpp     |   4 +-
 .../Editor/EditorBlastMeshDataComponent.cpp   |   4 +-
 .../Code/Source/Family/ActorRenderManager.cpp |   6 +-
 .../Blast/Code/Source/Family/ActorTracker.cpp |   3 +-
 .../Code/Source/Family/BlastFamilyImpl.cpp    |  12 +-
 .../EMotionFX/Source/EMotionFXManager.cpp     |   2 +-
 .../EMotionFX/Source/MultiThreadScheduler.cpp |   2 +-
 .../Integration/Components/ActorComponent.cpp |   2 +-
 .../ExpressionEvaluationSystemComponent.cpp   |   5 +-
 .../Include/GradientSignal/GradientSampler.h  |   3 +-
 .../Components/DitherGradientComponent.cpp    |   2 +-
 .../GradientSurfaceDataComponent.cpp          |   2 +-
 .../Components/GradientTransformComponent.cpp |   4 +-
 .../Components/ImageGradientComponent.cpp     |   2 +-
 .../Components/LevelsGradientComponent.cpp    |   2 +-
 .../Components/MixedGradientComponent.cpp     |   2 +-
 .../Components/PerlinGradientComponent.cpp    |   2 +-
 .../Components/RandomGradientComponent.cpp    |   2 +-
 .../Components/ReferenceGradientComponent.cpp |   2 +-
 .../ShapeAreaFalloffGradientComponent.cpp     |   2 +-
 .../SurfaceAltitudeGradientComponent.cpp      |   2 +-
 .../SurfaceMaskGradientComponent.cpp          |   2 +-
 .../GradientSignal/Code/Source/ImageAsset.cpp |   2 +-
 .../GraphCanvas/Editor/GraphCanvasProfiler.h  |   8 +-
 .../Dependency/DependencyMonitor.h            |   1 +
 .../Dependency/DependencyMonitor.inl          |  10 +-
 .../Code/Editor/PropertiesContainer.cpp       |   2 +-
 Gems/LyShine/Code/Editor/UiSliceManager.cpp   |  10 +-
 .../Code/Tests/MultiplayerCompressionTest.cpp |   1 +
 .../ClothComponentMesh/ActorClothSkinning.cpp |  12 +-
 .../ClothComponentMesh/ClothComponentMesh.cpp |  14 +-
 Gems/NvCloth/Code/Source/System/Cloth.cpp     |   2 +-
 .../Code/Source/System/FabricCooker.cpp       |   5 +-
 Gems/NvCloth/Code/Source/System/Solver.cpp    |  14 +-
 .../Code/Source/System/SystemComponent.cpp    |  12 +-
 .../Code/Source/System/TangentSpaceHelper.cpp |   8 +-
 .../Code/Source/Utils/MeshAssetHelper.cpp     |   2 +-
 .../Code/Source/ForceRegionComponent.cpp      |   2 +-
 .../Pipeline/HeightFieldAssetHandler.cpp      |   4 +-
 Gems/PhysX/Code/Source/Scene/PhysXScene.cpp   |  84 ++---
 Gems/PhysX/Code/Source/System/PhysXJob.cpp    |   2 +-
 .../Code/Source/System/PhysXSdkCallbacks.cpp  |   8 +-
 Gems/PhysX/Code/Source/System/PhysXSystem.cpp |   2 +-
 .../Code/Source/SystemComponent.cpp           |  20 +-
 .../Code/Source/ProfileTelemetryComponent.cpp |   2 +-
 .../Code/Source/RADTelemetryModule.cpp        |   2 +-
 .../Components/MeshOptimizer/MeshBuilder.cpp  |   2 +-
 .../Editor/Assets/ScriptCanvasMemoryAsset.cpp |   8 +-
 .../Editor/Assets/ScriptCanvasUndoHelper.cpp  |   4 +-
 .../Code/Editor/Nodes/NodeCreateUtils.cpp     |  22 +-
 .../Code/Editor/Nodes/NodeDisplayUtils.cpp    |  20 +-
 .../Include/ScriptCanvas/Core/EBusHandler.cpp |   2 +-
 .../Code/Include/ScriptCanvas/Core/Node.cpp   |  40 +--
 .../Execution/RuntimeComponent.cpp            |   4 +-
 .../Internal/Nodeables/BaseTimer.cpp          |   2 +-
 .../Internal/Nodes/StringFormatted.cpp        |   2 +-
 .../Libraries/Operators/Math/OperatorMul.cpp  |   2 +-
 .../Libraries/Time/DelayNodeable.cpp          |   2 +-
 .../Libraries/Time/DurationNodeable.cpp       |   2 +-
 .../Libraries/Time/TimerNodeable.cpp          |   2 +-
 .../SurfaceData/Utility/SurfaceDataUtility.h  |   3 +-
 .../SurfaceDataColliderComponent.cpp          |   6 +-
 .../Components/SurfaceDataShapeComponent.cpp  |   6 +-
 .../Source/SurfaceDataSystemComponent.cpp     |   7 +-
 .../Code/Source/SurfaceDataUtility.cpp        |   2 +-
 Gems/SurfaceData/Code/Source/SurfaceTag.cpp   |   6 +-
 .../Code/Source/AreaSystemComponent.cpp       |  48 +--
 .../Components/AreaBlenderComponent.cpp       |  10 +-
 .../Source/Components/AreaComponentBase.cpp   |   4 +-
 .../Source/Components/BlockerComponent.cpp    |   6 +-
 .../DescriptorListCombinerComponent.cpp       |   6 +-
 .../DescriptorWeightSelectorComponent.cpp     |   2 +-
 .../DistanceBetweenFilterComponent.cpp        |   2 +-
 .../DistributionFilterComponent.cpp           |   2 +-
 .../Components/MeshBlockerComponent.cpp       |   8 +-
 .../Components/PositionModifierComponent.cpp  |   2 +-
 .../Components/RotationModifierComponent.cpp  |   2 +-
 .../Components/ScaleModifierComponent.cpp     |   2 +-
 .../ShapeIntersectionFilterComponent.cpp      |   2 +-
 .../SlopeAlignmentModifierComponent.cpp       |   2 +-
 .../Source/Components/SpawnerComponent.cpp    |  20 +-
 .../SurfaceAltitudeFilterComponent.cpp        |   2 +-
 .../SurfaceMaskDepthFilterComponent.cpp       |   2 +-
 .../Components/SurfaceMaskFilterComponent.cpp |   2 +-
 .../SurfaceSlopeFilterComponent.cpp           |   2 +-
 .../Code/Source/InstanceSystemComponent.cpp   |  24 +-
 .../Code/Source/Core/WhiteBoxToolApi.cpp      | 184 +++++-----
 .../Code/Source/EditorWhiteBoxComponent.cpp   |  16 +-
 .../Source/EditorWhiteBoxComponentMode.cpp    |   6 +-
 .../EditorWhiteBoxComponentModeTypes.cpp      |   3 +-
 .../EditorWhiteBoxDefaultMode.cpp             |  10 +-
 274 files changed, 1435 insertions(+), 1965 deletions(-)
 create mode 100644 Code/Framework/AzCore/AzCore/Debug/MemoryProfiler.h

diff --git a/Code/Editor/CryEditDoc.cpp b/Code/Editor/CryEditDoc.cpp
index 90b020f452..b83babc5c5 100644
--- a/Code/Editor/CryEditDoc.cpp
+++ b/Code/Editor/CryEditDoc.cpp
@@ -1047,7 +1047,7 @@ static bool TryRenameFile(const QString& oldPath, const QString& newPath, int re
 
 bool CCryEditDoc::SaveLevel(const QString& filename)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+    AZ_PROFILE_FUNCTION(AzToolsFramework);
     QWaitCursor wait;
 
     CAutoCheckOutDialogEnableForAll enableForAll;
@@ -1067,7 +1067,7 @@ bool CCryEditDoc::SaveLevel(const QString& filename)
 
     {
 
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "CCryEditDoc::SaveLevel BackupBeforeSave");
+        AZ_PROFILE_SCOPE(AzToolsFramework, "CCryEditDoc::SaveLevel BackupBeforeSave");
         BackupBeforeSave();
     }
 
@@ -1178,7 +1178,7 @@ bool CCryEditDoc::SaveLevel(const QString& filename)
         CPakFile pakFile;
 
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "CCryEditDoc::SaveLevel Open PakFile");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "CCryEditDoc::SaveLevel Open PakFile");
             if (!pakFile.Open(tempSaveFile.toUtf8().data(), false))
             {
                 gEnv->pLog->LogWarning("Unable to open pack file %s for writing", tempSaveFile.toUtf8().data());
@@ -1209,7 +1209,7 @@ bool CCryEditDoc::SaveLevel(const QString& filename)
 
         AZ::IO::ByteContainerStream<AZStd::vector<char>> entitySaveStream(&entitySaveBuffer);
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "CCryEditDoc::SaveLevel Save Entities To Stream");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "CCryEditDoc::SaveLevel Save Entities To Stream");
             EBUS_EVENT_RESULT(
                 savedEntities, AzToolsFramework::EditorEntityContextRequestBus, SaveToStreamForEditor, entitySaveStream, layerEntities,
                 instancesInLayers);
@@ -1223,7 +1223,7 @@ bool CCryEditDoc::SaveLevel(const QString& filename)
 
         if (savedEntities)
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "CCryEditDoc::SaveLevel Updated PakFile levelEntities.editor_xml");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "CCryEditDoc::SaveLevel Updated PakFile levelEntities.editor_xml");
             pakFile.UpdateFile("LevelEntities.editor_xml", entitySaveBuffer.begin(), entitySaveBuffer.size());
 
             // Save XML archive to pak file.
diff --git a/Code/Editor/EditorViewportWidget.cpp b/Code/Editor/EditorViewportWidget.cpp
index 28e8cce33e..37ddb993f2 100644
--- a/Code/Editor/EditorViewportWidget.cpp
+++ b/Code/Editor/EditorViewportWidget.cpp
@@ -1950,7 +1950,7 @@ QPoint EditorViewportWidget::WorldToViewParticleEditor(const Vec3& wp, int width
 Vec3 EditorViewportWidget::ViewToWorld(
     const QPoint& vp, bool* collideWithTerrain, bool onlyTerrain, bool bSkipVegetation, bool bTestRenderMesh, bool* collideWithObject) const
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     AZ_UNUSED(collideWithTerrain)
     AZ_UNUSED(onlyTerrain)
@@ -1985,7 +1985,7 @@ Vec3 EditorViewportWidget::ViewToWorldNormal(const QPoint& vp, bool onlyTerrain,
     AZ_UNUSED(onlyTerrain)
     AZ_UNUSED(bTestRenderMesh)
 
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     return Vec3(0, 0, 1);
 }
diff --git a/Code/Editor/Objects/AxisGizmo.cpp b/Code/Editor/Objects/AxisGizmo.cpp
index 8f81ea66b7..a603b2615d 100644
--- a/Code/Editor/Objects/AxisGizmo.cpp
+++ b/Code/Editor/Objects/AxisGizmo.cpp
@@ -274,7 +274,7 @@ Matrix34 CAxisGizmo::GetTransformation(RefCoordSys coordSys, IDisplayViewport* v
 //////////////////////////////////////////////////////////////////////////
 bool CAxisGizmo::MouseCallback(CViewport* view, EMouseEvent event, QPoint& point, [[maybe_unused]] int nFlags)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     if (event == eMouseLDown)
     {
diff --git a/Code/Editor/Objects/BaseObject.cpp b/Code/Editor/Objects/BaseObject.cpp
index 482055d7ed..c9002f2dfa 100644
--- a/Code/Editor/Objects/BaseObject.cpp
+++ b/Code/Editor/Objects/BaseObject.cpp
@@ -1233,7 +1233,7 @@ float CBaseObject::GetCameraVisRatio(const CCamera& camera)
 //////////////////////////////////////////////////////////////////////////
 int CBaseObject::MouseCreateCallback(CViewport* view, EMouseEvent event, QPoint& point, int flags)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     if (event == eMouseMove || event == eMouseLDown)
     {
@@ -1928,7 +1928,7 @@ bool CBaseObject::HitTestRectBounds(HitContext& hc, const AABB& box)
 //////////////////////////////////////////////////////////////////////////
 bool CBaseObject::HitTestRect(HitContext& hc)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+    AZ_PROFILE_FUNCTION(Entity);
 
     AABB box;
 
@@ -1965,7 +1965,7 @@ bool CBaseObject::HitHelperTest(HitContext& hc)
 //////////////////////////////////////////////////////////////////////////
 bool CBaseObject::HitHelperAtTest(HitContext& hc, const Vec3& pos)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+    AZ_PROFILE_FUNCTION(Entity);
 
     bool bResult = false;
 
diff --git a/Code/Editor/Objects/EntityObject.cpp b/Code/Editor/Objects/EntityObject.cpp
index 0f4a17f3ba..b42afb5c39 100644
--- a/Code/Editor/Objects/EntityObject.cpp
+++ b/Code/Editor/Objects/EntityObject.cpp
@@ -497,7 +497,7 @@ bool CEntityObject::HitTestRect(HitContext& hc)
 //////////////////////////////////////////////////////////////////////////
 int CEntityObject::MouseCreateCallback(CViewport* view, EMouseEvent event, QPoint& point, int flags)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     if (event == eMouseMove || event == eMouseLDown)
     {
diff --git a/Code/Editor/Objects/ObjectManager.cpp b/Code/Editor/Objects/ObjectManager.cpp
index fbdd56f080..61a8944a90 100644
--- a/Code/Editor/Objects/ObjectManager.cpp
+++ b/Code/Editor/Objects/ObjectManager.cpp
@@ -368,7 +368,7 @@ CBaseObject* CObjectManager::NewObject(const QString& typeName, CBaseObject* pre
 //////////////////////////////////////////////////////////////////////////
 void    CObjectManager::DeleteObject(CBaseObject* obj)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
     if (m_currEditObject == obj)
     {
         EndEditParams();
@@ -414,7 +414,7 @@ void    CObjectManager::DeleteObject(CBaseObject* obj)
 //////////////////////////////////////////////////////////////////////////
 void CObjectManager::DeleteSelection(CSelectionGroup* pSelection)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
     if (pSelection == nullptr)
     {
         return;
@@ -478,7 +478,7 @@ void CObjectManager::DeleteSelection(CSelectionGroup* pSelection)
 //////////////////////////////////////////////////////////////////////////
 void CObjectManager::DeleteAllObjects()
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     EndEditParams();
 
@@ -519,7 +519,7 @@ void CObjectManager::DeleteAllObjects()
 
 CBaseObject* CObjectManager::CloneObject(CBaseObject* obj)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
     assert(obj);
     //CRuntimeClass *cls = obj->GetRuntimeClass();
     //CBaseObject *clone = (CBaseObject*)cls->CreateObject();
@@ -1112,7 +1112,7 @@ void CObjectManager::SerializeNameSelection(XmlNodeRef& rootNode, bool bLoading)
 //////////////////////////////////////////////////////////////////////////
 int CObjectManager::ClearSelection()
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     // Make sure to unlock selection.
     GetIEditor()->LockSelection(false);
@@ -1165,7 +1165,7 @@ int CObjectManager::ClearSelection()
 //////////////////////////////////////////////////////////////////////////
 int CObjectManager::InvertSelection()
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     int selCount = 0;
     // iterate all objects.
@@ -1189,7 +1189,7 @@ int CObjectManager::InvertSelection()
 
 void CObjectManager::SetSelection(const QString& name)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
     CSelectionGroup* selection = stl::find_in_map(m_selections, name, (CSelectionGroup*)nullptr);
     if (selection)
     {
@@ -1202,7 +1202,7 @@ void CObjectManager::SetSelection(const QString& name)
 
 void CObjectManager::RemoveSelection(const QString& name)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     QString selName = name;
     CSelectionGroup* selection = stl::find_in_map(m_selections, name, (CSelectionGroup*)nullptr);
@@ -1221,7 +1221,7 @@ void CObjectManager::RemoveSelection(const QString& name)
 
 void CObjectManager::SelectCurrent()
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
     for (int i = 0; i < m_currSelection->GetCount(); i++)
     {
         CBaseObject* obj = m_currSelection->GetObject(i);
@@ -1236,7 +1236,7 @@ void CObjectManager::SelectCurrent()
 
 void CObjectManager::UnselectCurrent()
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     // Make sure to unlock selection.
     GetIEditor()->LockSelection(false);
@@ -1260,7 +1260,7 @@ void CObjectManager::UnselectCurrent()
 //////////////////////////////////////////////////////////////////////////
 void CObjectManager::Display(DisplayContext& dc)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     int currentHideMask = GetIEditor()->GetDisplaySettings()->GetObjectHideMask();
     if (m_lastHideMask != currentHideMask)
@@ -1320,7 +1320,7 @@ void CObjectManager::FindDisplayableObjects(DisplayContext& dc, [[maybe_unused]]
         return;
     }
 
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     auto start = std::chrono::steady_clock::now();
     CBaseObjectsCache* pDispayedViewObjects = dc.view->GetVisibleObjectsCache();
@@ -1451,7 +1451,7 @@ void CObjectManager::EndEditParams([[maybe_unused]] int flags)
 //! Select objects within specified distance from given position.
 int CObjectManager::SelectObjects(const AABB& box, bool bUnselect)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
     int numSel = 0;
 
     AABB objBounds;
@@ -1551,7 +1551,7 @@ bool CObjectManager::IsObjectDeletionAllowed(CBaseObject* pObject)
 //////////////////////////////////////////////////////////////////////////
 void CObjectManager::DeleteSelection()
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     // Make sure to unlock selection.
     GetIEditor()->LockSelection(false);
@@ -1581,7 +1581,7 @@ void CObjectManager::DeleteSelection()
 //////////////////////////////////////////////////////////////////////////
 bool CObjectManager::HitTestObject(CBaseObject* obj, HitContext& hc)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     if (obj->IsFrozen())
     {
@@ -1648,7 +1648,7 @@ bool CObjectManager::HitTestObject(CBaseObject* obj, HitContext& hc)
 //////////////////////////////////////////////////////////////////////////
 bool CObjectManager::HitTest(HitContext& hitInfo)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     hitInfo.object = nullptr;
     hitInfo.dist = FLT_MAX;
@@ -1766,7 +1766,7 @@ bool CObjectManager::HitTest(HitContext& hitInfo)
 }
 void CObjectManager::FindObjectsInRect(CViewport* view, const QRect& rect, std::vector<GUID>& guids)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     if (rect.width() < 1 || rect.height() < 1)
     {
@@ -1795,7 +1795,7 @@ void CObjectManager::FindObjectsInRect(CViewport* view, const QRect& rect, std::
 //////////////////////////////////////////////////////////////////////////
 void CObjectManager::SelectObjectsInRect(CViewport* view, const QRect& rect, bool bSelect)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     // Ignore too small rectangles.
     if (rect.width() < 1 || rect.height() < 1)
@@ -2363,7 +2363,7 @@ bool CObjectManager::ConvertToType(CBaseObject* pObject, const QString& typeName
 //////////////////////////////////////////////////////////////////////////
 void CObjectManager::SetObjectSelected(CBaseObject* pObject, bool bSelect)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
     // Only select/unselect once.
     if ((pObject->IsSelected() && bSelect) || (!pObject->IsSelected() && !bSelect))
     {
diff --git a/Code/Editor/Objects/ObjectManagerLegacyUndo.cpp b/Code/Editor/Objects/ObjectManagerLegacyUndo.cpp
index f21ba46e65..08a7f4cf48 100644
--- a/Code/Editor/Objects/ObjectManagerLegacyUndo.cpp
+++ b/Code/Editor/Objects/ObjectManagerLegacyUndo.cpp
@@ -204,7 +204,7 @@ CUndoBaseObjectBulkSelect::CUndoBaseObjectBulkSelect(const AZStd::unordered_set<
 
 void CUndoBaseObjectBulkSelect::Undo(bool bUndo)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
     if (!bUndo)
     {
         return;
@@ -217,7 +217,7 @@ void CUndoBaseObjectBulkSelect::Undo(bool bUndo)
 
 void CUndoBaseObjectBulkSelect::Redo()
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     AzToolsFramework::ToolsApplicationRequestBus::Broadcast(
         &AzToolsFramework::ToolsApplicationRequests::MarkEntitiesSelected,
@@ -256,7 +256,7 @@ CUndoBaseObjectClearSelection::CUndoBaseObjectClearSelection(const CSelectionGro
 
 void CUndoBaseObjectClearSelection::Undo(bool bUndo)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     if (!bUndo)
     {
@@ -270,7 +270,7 @@ void CUndoBaseObjectClearSelection::Undo(bool bUndo)
 
 void CUndoBaseObjectClearSelection::Redo() 
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     AzToolsFramework::ToolsApplicationRequestBus::Broadcast(
         &AzToolsFramework::ToolsApplicationRequests::SetSelectedEntities,
diff --git a/Code/Editor/Plugins/ComponentEntityEditorPlugin/Objects/ComponentEntityObject.cpp b/Code/Editor/Plugins/ComponentEntityEditorPlugin/Objects/ComponentEntityObject.cpp
index 85730d327b..ba08b5c069 100644
--- a/Code/Editor/Plugins/ComponentEntityEditorPlugin/Objects/ComponentEntityObject.cpp
+++ b/Code/Editor/Plugins/ComponentEntityEditorPlugin/Objects/ComponentEntityObject.cpp
@@ -679,7 +679,7 @@ bool CComponentEntityObject::HitHelperTest(HitContext& hc)
 
 bool CComponentEntityObject::HitTest(HitContext& hc)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+    AZ_PROFILE_FUNCTION(Entity);
 
     if (m_iconOnlyHitTest)
     {
@@ -705,7 +705,7 @@ bool CComponentEntityObject::HitTest(HitContext& hc)
                     [&hc, &closestDistance, &rayIntersection, &preciseSelectionRequired, viewportId](
                         AzToolsFramework::EditorComponentSelectionRequests* handler) -> bool
                 {
-                    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+                    AZ_PROFILE_FUNCTION(Entity);
 
                     if (handler->SupportsEditorRayIntersect())
                     {
@@ -768,7 +768,7 @@ bool CComponentEntityObject::HitTest(HitContext& hc)
 
 void CComponentEntityObject::GetBoundBox(AABB& box)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+    AZ_PROFILE_FUNCTION(Entity);
 
     box.Reset();
 
diff --git a/Code/Editor/Plugins/ComponentEntityEditorPlugin/SandboxIntegration.cpp b/Code/Editor/Plugins/ComponentEntityEditorPlugin/SandboxIntegration.cpp
index 6b60f96089..ac393607ae 100644
--- a/Code/Editor/Plugins/ComponentEntityEditorPlugin/SandboxIntegration.cpp
+++ b/Code/Editor/Plugins/ComponentEntityEditorPlugin/SandboxIntegration.cpp
@@ -472,7 +472,7 @@ void SandboxIntegrationManager::EntityParentChanged(
     const AZ::EntityId newParentId,
     const AZ::EntityId oldParentId)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+    AZ_PROFILE_FUNCTION(AzToolsFramework);
 
     if (m_unsavedEntities.find(entityId) != m_unsavedEntities.end())
     {
@@ -858,7 +858,7 @@ void SandboxIntegrationManager::SetupLayerContextMenu(QMenu* menu)
 
 void SandboxIntegrationManager::SetupSliceContextMenu(QMenu* menu)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
     AzToolsFramework::EntityIdList selectedEntities;
     GetSelectedOrHighlightedEntities(selectedEntities);
 
@@ -960,7 +960,7 @@ void SandboxIntegrationManager::SetupSliceContextMenu(QMenu* menu)
 
 void SandboxIntegrationManager::SetupSliceContextMenu_Modify(QMenu* menu, const AzToolsFramework::EntityIdList& selectedEntities, [[maybe_unused]] const AZ::u32 numEntitiesInSlices)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
     using namespace AzToolsFramework;
 
     // Gather the set of relevant entities from the selected entities and all descendants
@@ -1083,7 +1083,7 @@ void SandboxIntegrationManager::CreateEditorRepresentation(AZ::Entity* entity)
 
 bool SandboxIntegrationManager::DestroyEditorRepresentation(AZ::EntityId entityId, bool deleteAZEntity)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+    AZ_PROFILE_FUNCTION(AzToolsFramework);
 
     IEditor* editor = GetIEditor();
     if (editor->GetObjectManager())
@@ -1095,7 +1095,7 @@ bool SandboxIntegrationManager::DestroyEditorRepresentation(AZ::EntityId entityI
         {
             static_cast<CComponentEntityObject*>(object)->AssignEntity(nullptr, deleteAZEntity);
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "SandboxIntegrationManager::DestroyEditorRepresentation:ObjManagerDeleteObject");
+                AZ_PROFILE_SCOPE(AzToolsFramework, "SandboxIntegrationManager::DestroyEditorRepresentation:ObjManagerDeleteObject");
                 editor->GetObjectManager()->DeleteObject(object);
             }
             return true;
@@ -1217,7 +1217,7 @@ void SandboxIntegrationManager::ClearRedoStack()
 
 void SandboxIntegrationManager::CloneSelection(bool& handled)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+    AZ_PROFILE_FUNCTION(AzToolsFramework);
 
     AzToolsFramework::EntityIdList entities;
     AzToolsFramework::ToolsApplicationRequests::Bus::BroadcastResult(
@@ -1850,7 +1850,7 @@ AZStd::string SandboxIntegrationManager::GetComponentEditorIcon(const AZ::Uuid&
 AZStd::string SandboxIntegrationManager::GetComponentIconPath(const AZ::Uuid& componentType,
     AZ::Crc32 componentIconAttrib, AZ::Component* component)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+    AZ_PROFILE_FUNCTION(AzToolsFramework);
     if (componentIconAttrib != AZ::Edit::Attributes::Icon
         && componentIconAttrib != AZ::Edit::Attributes::ViewportIcon
         && componentIconAttrib != AZ::Edit::Attributes::HideIcon)
diff --git a/Code/Editor/Plugins/ComponentEntityEditorPlugin/UI/Outliner/OutlinerListModel.cpp b/Code/Editor/Plugins/ComponentEntityEditorPlugin/UI/Outliner/OutlinerListModel.cpp
index 02d2174fb8..7d63f8e15b 100644
--- a/Code/Editor/Plugins/ComponentEntityEditorPlugin/UI/Outliner/OutlinerListModel.cpp
+++ b/Code/Editor/Plugins/ComponentEntityEditorPlugin/UI/Outliner/OutlinerListModel.cpp
@@ -1054,7 +1054,7 @@ bool OutlinerListModel::dropMimeDataEntities(const QMimeData* data, Qt::DropActi
 
 bool OutlinerListModel::CanReparentEntities(const AZ::EntityId& newParentId, const AzToolsFramework::EntityIdList &selectedEntityIds) const
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+    AZ_PROFILE_FUNCTION(AzToolsFramework);
     if (selectedEntityIds.empty())
     {
         return false;
@@ -1143,7 +1143,7 @@ bool OutlinerListModel::CanReparentEntities(const AZ::EntityId& newParentId, con
 
 bool OutlinerListModel::ReparentEntities(const AZ::EntityId& newParentId, const AzToolsFramework::EntityIdList &selectedEntityIds, const AZ::EntityId& beforeEntityId)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+    AZ_PROFILE_FUNCTION(AzToolsFramework);
     if (!CanReparentEntities(newParentId, selectedEntityIds))
     {
         return false;
@@ -1233,7 +1233,7 @@ bool OutlinerListModel::ReparentEntities(const AZ::EntityId& newParentId, const
 
 QMimeData* OutlinerListModel::mimeData(const QModelIndexList& indexes) const
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+    AZ_PROFILE_FUNCTION(AzToolsFramework);
     AZ::TypeId uuid1 = AZ::AzTypeInfo<AZ::Entity>::Uuid();
     AZ::TypeId uuid2 = AZ::AzTypeInfo<AzToolsFramework::EditorEntityIdContainer>::Uuid();
 
@@ -1323,7 +1323,7 @@ public:
 
 void OutlinerListModel::ProcessEntityUpdates()
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
     m_entityChangeQueued = false;
     if (m_layoutResetQueued)
     {
@@ -1331,7 +1331,7 @@ void OutlinerListModel::ProcessEntityUpdates()
     }
 
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Editor, "OutlinerListModel::ProcessEntityUpdates:ExpandQueue");
+        AZ_PROFILE_SCOPE(Editor, "OutlinerListModel::ProcessEntityUpdates:ExpandQueue");
         for (auto entityId : m_entityExpandQueue)
         {
             emit ExpandEntity(entityId, IsExpanded(entityId));
@@ -1340,7 +1340,7 @@ void OutlinerListModel::ProcessEntityUpdates()
     }
 
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Editor, "OutlinerListModel::ProcessEntityUpdates:SelectQueue");
+        AZ_PROFILE_SCOPE(Editor, "OutlinerListModel::ProcessEntityUpdates:SelectQueue");
         for (auto entityId : m_entitySelectQueue)
         {
             emit SelectEntity(entityId, AzToolsFramework::IsSelected(entityId));
@@ -1350,7 +1350,7 @@ void OutlinerListModel::ProcessEntityUpdates()
 
     if (!m_entityChangeQueue.empty())
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Editor, "OutlinerListModel::ProcessEntityUpdates:ChangeQueue");
+        AZ_PROFILE_SCOPE(Editor, "OutlinerListModel::ProcessEntityUpdates:ChangeQueue");
 
         // its faster to just do a bulk data change than to carefully pick out indices
         // so we'll just merge all ranges into a single range rather than try to make gaps
@@ -1383,7 +1383,7 @@ void OutlinerListModel::ProcessEntityUpdates()
     }
 
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Editor, "OutlinerListModel::ProcessEntityUpdates:LayoutChanged");
+        AZ_PROFILE_SCOPE(Editor, "OutlinerListModel::ProcessEntityUpdates:LayoutChanged");
         if (m_entityLayoutQueued)
         {
             emit layoutAboutToBeChanged();
@@ -1393,7 +1393,7 @@ void OutlinerListModel::ProcessEntityUpdates()
     }
 
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Editor, "OutlinerListModel::ProcessEntityUpdates:InvalidateFilter");
+        AZ_PROFILE_SCOPE(Editor, "OutlinerListModel::ProcessEntityUpdates:InvalidateFilter");
         if (m_isFilterDirty)
         {
             InvalidateFilter();
@@ -1416,7 +1416,7 @@ void OutlinerListModel::OnEntityInfoResetEnd()
 
 void OutlinerListModel::ProcessEntityInfoResetEnd()
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+    AZ_PROFILE_FUNCTION(AzToolsFramework);
     m_layoutResetQueued = false;
     m_entityChangeQueued = false;
     m_entityChangeQueue.clear();
@@ -1437,7 +1437,7 @@ void OutlinerListModel::OnEntityInfoUpdatedAddChildBegin(AZ::EntityId parentId,
 void OutlinerListModel::OnEntityInfoUpdatedAddChildEnd(AZ::EntityId parentId, AZ::EntityId childId)
 {
     (void)parentId;
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+    AZ_PROFILE_FUNCTION(AzToolsFramework);
     endInsertRows();
 
     //expand ancestors if a new descendant is already selected
@@ -1475,7 +1475,7 @@ void OutlinerListModel::OnEntityInfoUpdatedRemoveChildBegin(AZ::EntityId parentI
 void OutlinerListModel::OnEntityInfoUpdatedRemoveChildEnd(AZ::EntityId parentId, AZ::EntityId childId)
 {
     (void)childId;
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+    AZ_PROFILE_FUNCTION(AzToolsFramework);
 
     endResetModel();
 
@@ -1494,7 +1494,7 @@ void OutlinerListModel::OnEntityInfoUpdatedOrderBegin(AZ::EntityId parentId, AZ:
 
 void OutlinerListModel::OnEntityInfoUpdatedOrderEnd(AZ::EntityId parentId, AZ::EntityId childId, AZ::u64 index)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
     (void)index;
     m_entityLayoutQueued = true;
     QueueEntityUpdate(parentId);
@@ -1565,7 +1565,7 @@ QString OutlinerListModel::GetSliceAssetName(const AZ::EntityId& entityId) const
 
 QModelIndex OutlinerListModel::GetIndexFromEntity(const AZ::EntityId& entityId, int column) const
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+    AZ_PROFILE_FUNCTION(AzToolsFramework);
 
     if (entityId.IsValid())
     {
@@ -1727,7 +1727,7 @@ void OutlinerListModel::OnEditorEntityDuplicated(const AZ::EntityId& oldEntity,
 
 void OutlinerListModel::ExpandAncestors(const AZ::EntityId& entityId)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+    AZ_PROFILE_FUNCTION(AzToolsFramework);
     //typically to reveal selected entities, expand all parent entities
     if (entityId.IsValid())
     {
@@ -1932,7 +1932,7 @@ bool OutlinerListModel::HasSelectedDescendant(const AZ::EntityId& entityId) cons
 
 bool OutlinerListModel::AreAllDescendantsSameLockState(const AZ::EntityId& entityId) const
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+    AZ_PROFILE_FUNCTION(AzToolsFramework);
     //TODO result can be cached in mutable map and cleared when any descendant changes to avoid recursion in deep hierarchies
     bool isLocked = false;
     AzToolsFramework::EditorEntityInfoRequestBus::EventResult(isLocked, entityId, &AzToolsFramework::EditorEntityInfoRequestBus::Events::IsJustThisEntityLocked);
@@ -1953,7 +1953,7 @@ bool OutlinerListModel::AreAllDescendantsSameLockState(const AZ::EntityId& entit
 
 bool OutlinerListModel::AreAllDescendantsSameVisibleState(const AZ::EntityId& entityId) const
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+    AZ_PROFILE_FUNCTION(AzToolsFramework);
     //TODO result can be cached in mutable map and cleared when any descendant changes to avoid recursion in deep hierarchies
 
     bool isVisible = AzToolsFramework::IsEntitySetToBeVisible(entityId);
diff --git a/Code/Editor/Plugins/ComponentEntityEditorPlugin/UI/Outliner/OutlinerWidget.cpp b/Code/Editor/Plugins/ComponentEntityEditorPlugin/UI/Outliner/OutlinerWidget.cpp
index 6e16ab6557..9ed7c4a144 100644
--- a/Code/Editor/Plugins/ComponentEntityEditorPlugin/UI/Outliner/OutlinerWidget.cpp
+++ b/Code/Editor/Plugins/ComponentEntityEditorPlugin/UI/Outliner/OutlinerWidget.cpp
@@ -96,7 +96,7 @@ namespace
 
     void SortEntityChildren(AZ::EntityId entityId, const EntityIdCompareFunc& comparer, AzToolsFramework::EntityOrderArray* newEntityOrder = nullptr)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AzToolsFramework::EntityOrderArray entityOrderArray = AzToolsFramework::GetEntityChildOrder(entityId);
         AZStd::sort(entityOrderArray.begin(), entityOrderArray.end(), comparer);
@@ -110,7 +110,7 @@ namespace
 
     void SortEntityChildrenRecursively(AZ::EntityId entityId, const EntityIdCompareFunc& comparer)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AzToolsFramework::EntityOrderArray entityOrderArray;
         SortEntityChildren(entityId, comparer, &entityOrderArray);
@@ -303,7 +303,7 @@ void OutlinerWidget::OnSelectionChanged(const QItemSelection& selected, const QI
         return;
     }
 
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+    AZ_PROFILE_FUNCTION(AzToolsFramework);
 
     AzToolsFramework::EntityIdList newlySelected;
     ExtractEntityIdsFromSelection(selected, newlySelected);
@@ -450,7 +450,7 @@ void OutlinerWidget::UpdateSelection()
 {
     if (m_selectionChangeQueued)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         m_selectionChangeInProgress = true;
 
@@ -458,7 +458,7 @@ void OutlinerWidget::UpdateSelection()
         {
             // Calling Deselect for a large number of items is very slow,
             // use a single ClearAndSelect call instead.
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "OutlinerWidget::ModelEntitySelectionChanged:ClearAndSelect");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "OutlinerWidget::ModelEntitySelectionChanged:ClearAndSelect");
 
             AzToolsFramework::EntityIdList selectedEntities;
             AzToolsFramework::ToolsApplicationRequests::Bus::BroadcastResult(selectedEntities, &AzToolsFramework::ToolsApplicationRequests::Bus::Events::GetSelectedEntities);
@@ -469,12 +469,12 @@ void OutlinerWidget::UpdateSelection()
         else
         {
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "OutlinerWidget::ModelEntitySelectionChanged:Deselect");
+                AZ_PROFILE_SCOPE(AzToolsFramework, "OutlinerWidget::ModelEntitySelectionChanged:Deselect");
                 m_gui->m_objectTree->selectionModel()->select(
                     BuildSelectionFromEntities(m_entitiesToDeselect), QItemSelectionModel::Deselect);
             }
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "OutlinerWidget::ModelEntitySelectionChanged:Select");
+                AZ_PROFILE_SCOPE(AzToolsFramework, "OutlinerWidget::ModelEntitySelectionChanged:Select");
                 m_gui->m_objectTree->selectionModel()->select(
                     BuildSelectionFromEntities(m_entitiesToSelect), QItemSelectionModel::Select);
             }
@@ -497,7 +497,7 @@ void OutlinerWidget::UpdateSelection()
 template <class EntityIdCollection>
 QItemSelection OutlinerWidget::BuildSelectionFromEntities(const EntityIdCollection& entityIds)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+    AZ_PROFILE_FUNCTION(AzToolsFramework);
     QItemSelection selection;
 
     for (const auto& entityId : entityIds)
@@ -517,7 +517,7 @@ QItemSelection OutlinerWidget::BuildSelectionFromEntities(const EntityIdCollecti
 
 void OutlinerWidget::contextMenuEvent(QContextMenuEvent* event)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     bool isDocumentOpen = false;
     EBUS_EVENT_RESULT(isDocumentOpen, AzToolsFramework::EditorRequests::Bus, IsLevelDocumentOpen);
@@ -1272,7 +1272,7 @@ void OutlinerWidget::ExtractEntityIdsFromSelection(const QItemSelection& selecti
 
 void OutlinerWidget::OnSearchTextChanged(const QString& activeTextFilter)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+    AZ_PROFILE_FUNCTION(AzToolsFramework);
     AZStd::string filterString = activeTextFilter.toUtf8().data();
 
     m_listModel->SearchStringChanged(filterString);
@@ -1388,7 +1388,7 @@ void OutlinerWidget::QueueContentUpdateSort(const AZ::EntityId& entityId)
 
 void OutlinerWidget::SortContent()
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+    AZ_PROFILE_FUNCTION(AzToolsFramework);
 
     m_sortContentQueued = false;
 
@@ -1424,7 +1424,7 @@ void OutlinerWidget::OnSortModeChanged(EntityOutliner::DisplaySortMode sortMode)
 
     if (sortMode != EntityOutliner::DisplaySortMode::Manually)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         auto comparer = AZStd::bind(&CompareEntitiesForSorting, AZStd::placeholders::_1, AZStd::placeholders::_2, sortMode);
         SortEntityChildrenRecursively(AZ::EntityId(), comparer);
     }
diff --git a/Code/Editor/Plugins/EditorAssetImporter/AssetImporterDocument.cpp b/Code/Editor/Plugins/EditorAssetImporter/AssetImporterDocument.cpp
index db6e355799..c7e14d9c4e 100644
--- a/Code/Editor/Plugins/EditorAssetImporter/AssetImporterDocument.cpp
+++ b/Code/Editor/Plugins/EditorAssetImporter/AssetImporterDocument.cpp
@@ -43,7 +43,7 @@ AssetImporterDocument::AssetImporterDocument()
 
 bool AssetImporterDocument::LoadScene(const AZStd::string& sceneFullPath)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
     namespace SceneEvents = AZ::SceneAPI::Events;
     SceneEvents::SceneSerializationBus::BroadcastResult(m_scene, &SceneEvents::SceneSerializationBus::Events::LoadScene, sceneFullPath, AZ::Uuid::CreateNull());
     return !!m_scene;
diff --git a/Code/Editor/Plugins/EditorAssetImporter/ImporterRootDisplay.cpp b/Code/Editor/Plugins/EditorAssetImporter/ImporterRootDisplay.cpp
index 34527e598a..4f942a4251 100644
--- a/Code/Editor/Plugins/EditorAssetImporter/ImporterRootDisplay.cpp
+++ b/Code/Editor/Plugins/EditorAssetImporter/ImporterRootDisplay.cpp
@@ -45,7 +45,7 @@ AZ::SceneAPI::UI::ManifestWidget* ImporterRootDisplay::GetManifestWidget()
 
 void ImporterRootDisplay::SetSceneDisplay(const QString& headerText, const AZStd::shared_ptr<AZ::SceneAPI::Containers::Scene>& scene)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
     if (!scene)
     {
         AZ_Assert(scene, "No scene provided to display.");
@@ -62,7 +62,7 @@ void ImporterRootDisplay::SetSceneDisplay(const QString& headerText, const AZStd
 
 void ImporterRootDisplay::HandleSceneWasReset(const AZStd::shared_ptr<AZ::SceneAPI::Containers::Scene>& scene)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
     // Don't accept updates while the widget is being filled in.
     BusDisconnect();
     m_manifestWidget->BuildFromScene(scene);
diff --git a/Code/Editor/Plugins/EditorAssetImporter/SceneSerializationHandler.cpp b/Code/Editor/Plugins/EditorAssetImporter/SceneSerializationHandler.cpp
index c087a27ba4..b1d07af41c 100644
--- a/Code/Editor/Plugins/EditorAssetImporter/SceneSerializationHandler.cpp
+++ b/Code/Editor/Plugins/EditorAssetImporter/SceneSerializationHandler.cpp
@@ -6,6 +6,7 @@
  *
  */
 
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/IO/SystemFile.h>
 #include <AzCore/std/algorithm.h>
 #include <AzCore/std/string/conversions.h>
@@ -37,7 +38,7 @@ namespace AZ
     AZStd::shared_ptr<SceneAPI::Containers::Scene> SceneSerializationHandler::LoadScene(
         const AZStd::string& filePath, Uuid sceneSourceGuid)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+        AZ_PROFILE_FUNCTION(Editor);
         namespace Utilities = AZ::SceneAPI::Utilities;
         using AZ::SceneAPI::Events::AssetImportRequest;
 
diff --git a/Code/Editor/Viewport.cpp b/Code/Editor/Viewport.cpp
index 873f555c80..fe60778c13 100644
--- a/Code/Editor/Viewport.cpp
+++ b/Code/Editor/Viewport.cpp
@@ -969,7 +969,7 @@ void QtViewport::MakeConstructionPlane(int axis)
 //////////////////////////////////////////////////////////////////////////
 Vec3 QtViewport::MapViewToCP(const QPoint& point, int axis)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     if (axis == AXIS_TERRAIN)
     {
@@ -1336,7 +1336,7 @@ bool QtViewport::GetAdvancedSelectModeFlag()
 //////////////////////////////////////////////////////////////////////////
 bool QtViewport::MouseCallback(EMouseEvent event, const QPoint& point, Qt::KeyboardModifiers modifiers, Qt::MouseButtons buttons)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+    AZ_PROFILE_FUNCTION(Editor);
 
     // Ignore any mouse events in game mode.
     if (GetIEditor()->IsInGameMode())
diff --git a/Code/Framework/AzCore/AzCore/Android/APKFileHandler.h b/Code/Framework/AzCore/AzCore/Android/APKFileHandler.h
index 0d9d3c984d..8df97a0cea 100644
--- a/Code/Framework/AzCore/AzCore/Android/APKFileHandler.h
+++ b/Code/Framework/AzCore/AzCore/Android/APKFileHandler.h
@@ -26,8 +26,8 @@
 #if AZ_ENABLED_VERBOSE_ANDROID_IO_PROFILING
     #include <AzCore/Debug/Profiler.h>
 
-    #define ANDROID_IO_PROFILE_SECTION           AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore)
-    #define ANDROID_IO_PROFILE_SECTION_ARGS(...) AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, __VA_ARGS__)
+    #define ANDROID_IO_PROFILE_SECTION           AZ_PROFILE_FUNCTION(AzCore)
+    #define ANDROID_IO_PROFILE_SECTION_ARGS(...) AZ_PROFILE_SCOPE(AzCore, __VA_ARGS__)
 #else
     #define ANDROID_IO_PROFILE_SECTION
     #define ANDROID_IO_PROFILE_SECTION_ARGS(...)
diff --git a/Code/Framework/AzCore/AzCore/Asset/AssetDataStream.cpp b/Code/Framework/AzCore/AzCore/Asset/AssetDataStream.cpp
index 425c729806..305ec0617b 100644
--- a/Code/Framework/AzCore/AzCore/Asset/AssetDataStream.cpp
+++ b/Code/Framework/AzCore/AzCore/Asset/AssetDataStream.cpp
@@ -27,7 +27,7 @@ namespace AZ::Data
 
     void AssetDataStream::Open(const AZStd::vector<AZ::u8>& data)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         AZ_Assert(!m_isOpen, "Attempting to open the stream when it is already open.");
 
@@ -45,7 +45,7 @@ namespace AZ::Data
 
     void AssetDataStream::Open(AZStd::vector<AZ::u8>&& data)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         AZ_Assert(!m_isOpen, "Attempting to open the stream when it is already open.");
 
@@ -62,7 +62,7 @@ namespace AZ::Data
         AZStd::chrono::milliseconds deadline, AZ::IO::IStreamerTypes::Priority priority,
         OnCompleteCallback loadCallback)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         AZ_Assert(!m_isOpen, "Attempting to open the stream when it is already open.");
         AZ_Assert(!m_curReadRequest, "Queueing an asset stream load while one is still in progress.");
@@ -80,7 +80,7 @@ namespace AZ::Data
             // Set up the callback that will process the asset data once the raw file load is finished.
             auto streamerCallback = [this, loadCallback](AZ::IO::FileRequestHandle fileHandle)
             {
-                AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "AZ::Data::LoadAssetDataStreamCallback %s",
+                AZ_PROFILE_SCOPE(AzCore, "AZ::Data::LoadAssetDataStreamCallback %s",
                     m_filePath.c_str());
 
                 // Get the results 
@@ -183,13 +183,13 @@ namespace AZ::Data
         // the real interval we want to record below won't show up unless this is here.
         /**/
         {
-            AZ_PROFILE_INTERVAL_START(AZ::Debug::ProfileCategory::AzCore, this + 1, "AssetDataStream: %s", streamName);
-            AZ_PROFILE_INTERVAL_END(AZ::Debug::ProfileCategory::AzCore, this + 1);
+            AZ_PROFILE_INTERVAL_START(AzCore, this + 1, "AssetDataStream: %s", streamName);
+            AZ_PROFILE_INTERVAL_END(AzCore, this + 1);
         }
         /**/
 
         // Start a timespan marker to track the full load time for the requested asset.
-        AZ_PROFILE_INTERVAL_START(AZ::Debug::ProfileCategory::AzCore, this, "AssetLoad: %s", streamName);
+        AZ_PROFILE_INTERVAL_START(AzCore, this, "AssetLoad: %s", streamName);
 
         // Lock the allocator to ensure it remains active from Open to Close.
         m_bufferAllocator->LockAllocator();
@@ -216,7 +216,7 @@ namespace AZ::Data
         ClearInternalStateData();
 
         // End the load time timespan marker for this asset.
-        AZ_PROFILE_INTERVAL_END(AZ::Debug::ProfileCategory::AzCore, this);
+        AZ_PROFILE_INTERVAL_END(AzCore, this);
     }
 
     void AssetDataStream::RequestCancel()
@@ -231,7 +231,7 @@ namespace AZ::Data
 
     void AssetDataStream::Seek(AZ::IO::OffsetType bytes, AZ::IO::GenericStream::SeekMode mode)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
         AZ::IO::OffsetType requestedOffset = 0;
 
         switch (mode)
@@ -261,7 +261,7 @@ namespace AZ::Data
 
     AZ::IO::SizeType AssetDataStream::Read(AZ::IO::SizeType bytes, void* oBuffer)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
         if (m_curOffset >= m_loadedSize)
         {
             return 0;
diff --git a/Code/Framework/AzCore/AzCore/Asset/AssetManager.cpp b/Code/Framework/AzCore/AzCore/Asset/AssetManager.cpp
index 2a71baea46..f31859c14d 100644
--- a/Code/Framework/AzCore/AzCore/Asset/AssetManager.cpp
+++ b/Code/Framework/AzCore/AzCore/Asset/AssetManager.cpp
@@ -163,7 +163,7 @@ namespace AZ
                 else
                 {
 
-                    AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "AZ::Data::LoadAssetJob::Process: %s",
+                    AZ_PROFILE_SCOPE(AzCore, "AZ::Data::LoadAssetJob::Process: %s",
                         asset.GetHint().c_str());
 
                     AZ_ASSET_ATTACH_TO_SCOPE(this);
@@ -198,7 +198,7 @@ namespace AZ
 
                 if(cl_assetLoadDelay > 0)
                 {
-                    AZ_PROFILE_SCOPE_IDLE(AZ::Debug::ProfileCategory::AzCore, "LoadData suspended");
+                    AZ_PROFILE_SCOPE(AzCore, "LoadData suspended");
                     AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(cl_assetLoadDelay));
                 }
 
@@ -314,7 +314,7 @@ namespace AZ
         protected:
             void Wait()
             {
-                AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "WaitForAsset - %s", m_assetData.GetHint().c_str());
+                AZ_PROFILE_SCOPE(AzCore, "WaitForAsset - %s", m_assetData.GetHint().c_str());
 
                 // Continue to loop until the load completes.  (Most of the time in the loop will be spent in a thread-blocking state)
                 while (!m_loadCompleted)
@@ -344,7 +344,7 @@ namespace AZ
 
             void Finish()
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+                AZ_PROFILE_FUNCTION(AzCore);
                 m_loadCompleted = true;
                 m_waitEvent.release();
             }
@@ -403,7 +403,7 @@ namespace AZ
             void SaveAsset()
             {
                 auto asset = m_asset.GetStrongReference();
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+                AZ_PROFILE_FUNCTION(AzCore);
                 bool isSaved = false;
                 AssetStreamInfo saveInfo = m_owner->GetSaveStreamInfoForAsset(asset.GetId(), asset.GetType());
                 if (saveInfo.IsValid())
@@ -565,7 +565,7 @@ namespace AZ
         //=========================================================================
         void AssetManager::DispatchEvents()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
             AssetManagerNotificationBus::Broadcast(&AssetManagerNotificationBus::Events::OnAssetEventsDispatchBegin);
             AssetBus::ExecuteQueuedEvents();
             AssetManagerNotificationBus::Broadcast(&AssetManagerNotificationBus::Events::OnAssetEventsDispatchEnd);
@@ -937,14 +937,14 @@ namespace AZ
         Asset<AssetData> AssetManager::GetAssetInternal(const AssetId& assetId, [[maybe_unused]] const AssetType& assetType,
             AssetLoadBehavior assetReferenceLoadBehavior, const AssetLoadParameters& loadParams, AssetInfo assetInfo /*= () */, bool signalLoaded /*= false */)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             AZ_Error("AssetDatabase", assetId.IsValid(), "GetAsset called with invalid asset Id.");
             AZ_Error("AssetDatabase", !assetType.IsNull(), "GetAsset called with invalid asset type.");
             bool assetMissing = false;
 
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "GetAsset: GetAssetInfo");
+                AZ_PROFILE_SCOPE(AzCore, "GetAsset: GetAssetInfo");
 
                 // Attempt to look up asset info from catalog
                 // This is so that when assetId is a legacy id, we're operating on the canonical id anyway
@@ -974,7 +974,7 @@ namespace AZ
                 }
             }
 
-            AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "GetAsset: %s", assetInfo.m_relativePath.c_str());
+            AZ_PROFILE_SCOPE(AzCore, "GetAsset: %s", assetInfo.m_relativePath.c_str());
             AZ_ASSET_NAMED_SCOPE("GetAsset: %s", assetInfo.m_relativePath.c_str());
 
             AZStd::shared_ptr<AssetDataStream> dataStream;
@@ -992,7 +992,7 @@ namespace AZ
 
                 // check if asset already exists
                 {
-                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "GetAsset: FindAsset");
+                    AZ_PROFILE_SCOPE(AzCore, "GetAsset: FindAsset");
 
                     AssetMap::iterator it = m_assets.find(assetInfo.m_assetId);
                     if (it != m_assets.end())
@@ -1007,7 +1007,7 @@ namespace AZ
                 }
 
                 {
-                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "GetAsset: FindAssetHandler");
+                    AZ_PROFILE_SCOPE(AzCore, "GetAsset: FindAssetHandler");
 
                     // find the asset type handler
                     AssetHandlerMap::iterator handlerIt = m_handlers.find(assetInfo.m_assetType);
@@ -1019,7 +1019,7 @@ namespace AZ
                         handler = handlerIt->second;
                         if (isNewEntry)
                         {
-                            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "GetAsset: CreateAsset");
+                            AZ_PROFILE_SCOPE(AzCore, "GetAsset: CreateAsset");
 
                             assetData = handler->CreateAsset(assetInfo.m_assetId, assetInfo.m_assetType);
                             if (assetData)
@@ -1043,7 +1043,7 @@ namespace AZ
                 {
                     if (isNewEntry && assetData->IsRegisterReadonlyAndShareable())
                     {
-                        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "GetAsset: RegisterAsset");
+                        AZ_PROFILE_SCOPE(AzCore, "GetAsset: RegisterAsset");
                         m_assets.insert(AZStd::make_pair(assetInfo.m_assetId, assetData));
                     }
                     if (assetData->GetStatus() == AssetData::AssetStatus::NotLoaded)
@@ -1596,7 +1596,7 @@ namespace AZ
             const AZ::Data::AssetStreamInfo& streamInfo, bool isReload,
             AssetHandler* handler, const AssetLoadParameters& loadParams, bool signalLoaded)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             // Set up the callback that will process the asset data once the raw file load is finished.
             // The callback is declared as mutable so that we can clear weakAsset within the callback.  The refcount in weakAsset
@@ -1613,7 +1613,7 @@ namespace AZ
 
                 if (loadingAsset)
                 {
-                    AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "AZ::Data::LoadAssetStreamerCallback %s",
+                    AZ_PROFILE_SCOPE(AzCore, "AZ::Data::LoadAssetStreamerCallback %s",
                         loadingAsset.GetHint().c_str());
                     {
                         AZStd::scoped_lock<AZStd::recursive_mutex> assetLock(m_assetMutex);
@@ -1788,7 +1788,7 @@ namespace AZ
         //=========================================================================
         void AssetManager::RegisterAssetLoading(const Asset<AssetData>& asset)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             AssetData* data = asset.Get();
             if (data)
@@ -1803,7 +1803,7 @@ namespace AZ
         //=========================================================================
         void AssetManager::UnregisterAssetLoading([[maybe_unused]] const Asset<AssetData>& asset)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
         }
 
         //=========================================================================
@@ -2050,7 +2050,7 @@ namespace AZ
             AZStd::shared_ptr<AssetDataStream> stream,
             const AssetFilterCB& assetLoadFilterCB)
         {
-            AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "AssetHandler::LoadAssetData - %s", asset.GetHint().c_str());
+            AZ_PROFILE_SCOPE(AzCore, "AssetHandler::LoadAssetData - %s", asset.GetHint().c_str());
 
 #ifdef AZ_ENABLE_TRACING
             auto start = AZStd::chrono::system_clock::now();
@@ -2119,7 +2119,7 @@ namespace AZ
         void AssetManager::PostLoad(AZ::Data::Asset<AZ::Data::AssetData>& asset, bool loadSucceeded,
                                     bool isReload, AZ::Data::AssetHandler* assetHandler)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
             if (!assetHandler)
             {
                 assetHandler = GetHandler(asset.GetType());
diff --git a/Code/Framework/AzCore/AzCore/AzCoreModule.cpp b/Code/Framework/AzCore/AzCore/AzCoreModule.cpp
index 6afcb6a334..d2b1b141a9 100644
--- a/Code/Framework/AzCore/AzCore/AzCoreModule.cpp
+++ b/Code/Framework/AzCore/AzCore/AzCoreModule.cpp
@@ -19,7 +19,6 @@
 #include <AzCore/Slice/SliceComponent.h>
 #include <AzCore/Slice/SliceSystemComponent.h>
 #include <AzCore/Slice/SliceMetadataInfoComponent.h>
-#include <AzCore/Statistics/StatisticalProfilerProxySystemComponent.h>
 #include <AzCore/UserSettings/UserSettingsComponent.h>
 #include <AzCore/Time/TimeSystemComponent.h>
 #include <AzCore/Console/LoggerSystemComponent.h>
@@ -45,9 +44,6 @@ namespace AZ
             LoggerSystemComponent::CreateDescriptor(),
             EventSchedulerSystemComponent::CreateDescriptor(),
 
-#if !defined(_RELEASE)
-            Statistics::StatisticalProfilerProxySystemComponent::CreateDescriptor(),
-#endif // #if !defined(_RELEASE)
 #if !defined(AZCORE_EXCLUDE_LUA)
             ScriptSystemComponent::CreateDescriptor(),
 #endif // #if !defined(AZCORE_EXCLUDE_LUA)
@@ -61,10 +57,6 @@ namespace AZ
             azrtti_typeid<TimeSystemComponent>(),
             azrtti_typeid<LoggerSystemComponent>(),
             azrtti_typeid<EventSchedulerSystemComponent>(),
-
-#if !defined(_RELEASE)
-            azrtti_typeid<AZ::Statistics::StatisticalProfilerProxySystemComponent>(),
-#endif // #if !defined(_RELEASE)
         };
     }
 }
diff --git a/Code/Framework/AzCore/AzCore/Component/ComponentApplication.cpp b/Code/Framework/AzCore/AzCore/Component/ComponentApplication.cpp
index 7b1060a10f..5114ea19ec 100644
--- a/Code/Framework/AzCore/AzCore/Component/ComponentApplication.cpp
+++ b/Code/Framework/AzCore/AzCore/Component/ComponentApplication.cpp
@@ -1394,8 +1394,7 @@ namespace AZ
     void ComponentApplication::Tick(float deltaOverride /*= -1.f*/)
     {
         {
-            AZ_PROFILE_TIMER("System", "Component application simulation tick function");
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_SCOPE(System, "Component application simulation tick");
 
             AZStd::chrono::system_clock::time_point now = AZStd::chrono::system_clock::now();
 
@@ -1408,12 +1407,12 @@ namespace AZ
             }
 
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "ComponentApplication::Tick:ExecuteQueuedEvents");
+                AZ_PROFILE_SCOPE(AzCore, "ComponentApplication::Tick:ExecuteQueuedEvents");
                 TickBus::ExecuteQueuedEvents();
             }
             m_currentTime = now;
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "ComponentApplication::Tick:OnTick");
+                AZ_PROFILE_SCOPE(AzCore, "ComponentApplication::Tick:OnTick");
                 EBUS_EVENT(TickBus, OnTick, m_deltaTime, ScriptTimePoint(now));
             }
         }
@@ -1428,8 +1427,7 @@ namespace AZ
     //=========================================================================
     void ComponentApplication::TickSystem()
     {
-        AZ_PROFILE_TIMER("System", "Component application system tick function");
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_SCOPE(System, "Component application tick");
 
         SystemTickBus::ExecuteQueuedEvents();
         EBUS_EVENT(SystemTickBus, OnSystemTick);
diff --git a/Code/Framework/AzCore/AzCore/Component/Entity.cpp b/Code/Framework/AzCore/AzCore/Component/Entity.cpp
index 09b5526b6c..00c1895261 100644
--- a/Code/Framework/AzCore/AzCore/Component/Entity.cpp
+++ b/Code/Framework/AzCore/AzCore/Component/Entity.cpp
@@ -189,7 +189,7 @@ namespace AZ
 
     void Entity::Activate()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         AZ_Assert(m_state == State::Init, "Entity should be in Init state to be Activated!");
 
@@ -226,7 +226,7 @@ namespace AZ
 
     void Entity::Deactivate()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         AZ::ComponentApplicationRequests* componentApplication = AZ::Interface<AZ::ComponentApplicationRequests>::Get();
         if (componentApplication != nullptr)
@@ -1034,7 +1034,7 @@ namespace AZ
 
     Entity::DependencySortOutcome Entity::DependencySort(ComponentArrayType& inOutComponents)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         using DependencySortInternal::ComponentInfo;
         using DependencySortInternal::InvalidEntry;
diff --git a/Code/Framework/AzCore/AzCore/Component/EntityUtils.cpp b/Code/Framework/AzCore/AzCore/Component/EntityUtils.cpp
index 9bb41bfd58..8241400aac 100644
--- a/Code/Framework/AzCore/AzCore/Component/EntityUtils.cpp
+++ b/Code/Framework/AzCore/AzCore/Component/EntityUtils.cpp
@@ -40,7 +40,7 @@ namespace AZ
         //=========================================================================
         void EnumerateEntityIds(const void* classPtr, const Uuid& classUuid, const EntityIdVisitor& visitor, SerializeContext* context)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             if (!context)
             {
diff --git a/Code/Framework/AzCore/AzCore/Component/EntityUtils.h b/Code/Framework/AzCore/AzCore/Component/EntityUtils.h
index a5d0e4e53f..ce258bc637 100644
--- a/Code/Framework/AzCore/AzCore/Component/EntityUtils.h
+++ b/Code/Framework/AzCore/AzCore/Component/EntityUtils.h
@@ -54,7 +54,7 @@ namespace AZ
         template<class T>
         unsigned int ReplaceEntityRefs(T* classPtr, const EntityIdMapper& mapper, SerializeContext* context = nullptr)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
             auto idMapper = [&mapper](const EntityId& originalId, bool isEntityId, const IdUtils::Remapper<EntityId>::IdGenerator&) -> EntityId
             {
                 return mapper(originalId, isEntityId);
@@ -83,7 +83,7 @@ namespace AZ
         template<class T>
         unsigned int ReplaceEntityIds(T* classPtr, const EntityIdMapper& mapper, SerializeContext* context = nullptr)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
             auto idMapper = [&mapper](const EntityId& originalId, bool isEntityId, const IdUtils::Remapper<EntityId>::IdGenerator&) -> EntityId
             {
                 return mapper(originalId, isEntityId);
@@ -97,7 +97,7 @@ namespace AZ
         template<class T>
         unsigned int ReplaceEntityIdsAndEntityRefs(T* classPtr, const EntityIdMapper& mapper, SerializeContext* context = nullptr)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
             auto idMapper = [&mapper](const EntityId& originalId, bool isEntityId, const IdUtils::Remapper<EntityId>::IdGenerator&) -> EntityId
             {
                 return mapper(originalId, isEntityId);
diff --git a/Code/Framework/AzCore/AzCore/Debug/EventTrace.h b/Code/Framework/AzCore/AzCore/Debug/EventTrace.h
index 5faf08f46e..8d096707ba 100644
--- a/Code/Framework/AzCore/AzCore/Debug/EventTrace.h
+++ b/Code/Framework/AzCore/AzCore/Debug/EventTrace.h
@@ -42,11 +42,11 @@ namespace AZ
 #   define AZ_TRACE_METHOD_NAME_CATEGORY(name, category) AZ::Debug::EventTrace::ScopedSlice AZ_JOIN(ScopedSlice__, __LINE__)(name, category);
 #   define AZ_TRACE_METHOD_NAME(name) \
         AZ_TRACE_METHOD_NAME_CATEGORY(name, "") \
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzTrace, name)
+        AZ_PROFILE_SCOPE(AzTrace, name)
 
 #   define AZ_TRACE_METHOD() \
         AZ_TRACE_METHOD_NAME_CATEGORY(AZ_FUNCTION_SIGNATURE, "") \
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzTrace)
+        AZ_PROFILE_FUNCTION(AzTrace)
 #else
 #   define AZ_TRACE_METHOD_NAME_CATEGORY(name, category)
 #   define AZ_TRACE_METHOD_NAME(name) AZ_TRACE_METHOD_NAME_CATEGORY(name, "")
diff --git a/Code/Framework/AzCore/AzCore/Debug/MemoryProfiler.h b/Code/Framework/AzCore/AzCore/Debug/MemoryProfiler.h
new file mode 100644
index 0000000000..5b22e20c60
--- /dev/null
+++ b/Code/Framework/AzCore/AzCore/Debug/MemoryProfiler.h
@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+#pragma once
+
+#ifndef AZ_PROFILE_MEMORY_ALLOC
+// No other profiler has defined the performance markers AZ_PROFILE_MEMORY_ALLOC (and friends), fall back to a Driller implementation (currently empty)
+#   define AZ_PROFILE_MEMORY_ALLOC(category, address, size, context)
+#   define AZ_PROFILE_MEMORY_ALLOC_EX(category, filename, lineNumber, address, size, context)
+#   define AZ_PROFILE_MEMORY_FREE(category, address)
+#   define AZ_PROFILE_MEMORY_FREE_EX(category, filename, lineNumber, address)
+#endif
diff --git a/Code/Framework/AzCore/AzCore/Debug/Profiler.cpp b/Code/Framework/AzCore/AzCore/Debug/Profiler.cpp
index eda7330cfc..649bb0b8d7 100644
--- a/Code/Framework/AzCore/AzCore/Debug/Profiler.cpp
+++ b/Code/Framework/AzCore/AzCore/Debug/Profiler.cpp
@@ -18,14 +18,14 @@
 #include <AzCore/std/functional.h>
 #include <AzCore/Math/Crc.h>
 
-#ifdef USE_PIX
-#include <AzCore/PlatformIncl.h>
-#include <WinPixEventRuntime/pix3.h>
-#endif
-
-
 namespace AZ
 {
+    uint32_t ProfileScope::GetSystemID(const char* system)
+    {
+        // TODO: stable ids for registered budgets
+        return AZ::Crc32(system);
+    }
+
     namespace Debug
     {
         //////////////////////////////////////////////////////////////////////////
@@ -501,10 +501,6 @@ namespace AZ
         ProfilerRegister*
         ProfilerRegister::TimerCreateAndStart(const char* systemName, const char* name, ProfilerSection * section, const char* function, int line)
         {
-#if defined(USE_PIX)
-            PIXBeginEvent(PIX_COLOR(0, 0, 1), "%s:%s", name, function);
-#endif
-
             AZStd::chrono::system_clock::time_point start = AZStd::chrono::system_clock::now();
             ProfilerRegister* reg = CreateRegister(systemName, name, function, line, ProfilerRegister::PRT_TIME);
             AZStd::chrono::system_clock::time_point end = AZStd::chrono::system_clock::now();
@@ -548,10 +544,6 @@ namespace AZ
         {
             ProfilerRegister* reg = this;
 
-#if defined(USE_PIX)
-            PIXBeginEvent(PIX_COLOR(0, 0, 1), "%s:%s", reg->m_name, reg->m_function);
-#endif
-
             if (reg->m_isActive)
             {
                 section->m_register = reg;
@@ -570,10 +562,6 @@ namespace AZ
         //=========================================================================
         void ProfilerRegister::TimerStop()
         {
-#if defined(USE_PIX)
-            PIXEndEvent();
-#endif
-
             AZStd::chrono::system_clock::time_point end = AZStd::chrono::system_clock::now();
             ProfilerSection* section = m_threadData->m_stack.back();
             AZStd::chrono::microseconds elapsedTime = end - section->m_start;
diff --git a/Code/Framework/AzCore/AzCore/Debug/Profiler.h b/Code/Framework/AzCore/AzCore/Debug/Profiler.h
index 6dcdcfdddc..faf511e375 100644
--- a/Code/Framework/AzCore/AzCore/Debug/Profiler.h
+++ b/Code/Framework/AzCore/AzCore/Debug/Profiler.h
@@ -10,304 +10,48 @@
 #include <AzCore/std/chrono/chrono.h>
 #include <AzCore/std/function/function_fwd.h>
 
-namespace AZ
-{
-    namespace Debug
-    {
-        using ProfileCategoryPrimitiveType = AZ::u64;
+#ifdef USE_PIX
+#include <AzCore/PlatformIncl.h>
+#include <WinPixEventRuntime/pix3.h>
+// The pix3 header unfortunately brings in other Windows macros we need to undef
+#undef DeleteFile
+#undef LoadImage
+#endif
 
-        /**
-        * Profiling categories consumed by AZ_PROFILE_FUNCTION and AZ_PROFILE_SCOPE variants for profile filtering
-        */
-        enum class ProfileCategory : ProfileCategoryPrimitiveType
-        {
-            // These initial categories match up with the legacy EProfiledSubsystem categories
-            Any = 0,
-            Renderer,
-            ThreeDEngine,
-            Particle,
-            AI,
-            Animation,
-            Movie,
-            Entity,
-            Font,
-            Network,
-            Physics,
-            Script,
-            ScriptCFunc,
-            Audio,
-            Editor,
-            System,
-            Action,
-            Game,
-            Input,
-            Sync,
-
-            // Legacy network traffic categories
-            LegacyNetworkTrafficReserved,
-            LegacyDeviceReserved,
-
-            // must match EProfiledSubsystem::PROFILE_LAST_SUBSYSTEM
-            LegacyLast,
-
-            // Bulk category via AZ_TRACE_METHOD
-            AzTrace,
-
-            AzCore,
-            AzRender,
-            AzFramework,
-            AzToolsFramework,
-            ScriptCanvas,
-            LegacyTerrain,
-            Terrain,
-            Cloth,
-            // Add new major categories here (and add names to the parallel position in ProfileCategoryNames) - these categories are enabled by default
-
-            FirstDetailedCategory,
-            RendererDetailed = FirstDetailedCategory,
-            ThreeDEngineDetailed,
-            JobManagerDetailed,
-
-            AzRenderDetailed,
-            ClothDetailed,
-            // Add new detailed categories here (and add names to the parallel position in ProfileCategoryNames) -- these categories are disabled by default
-            
-            // Internal reserved categories, not for use with performance events
-            FirstReservedCategory,
-            MemoryReserved = FirstReservedCategory,
-            Global,
-
-            // Must be last
-            Count
-        };
-        static_assert(static_cast<size_t>(ProfileCategory::Count) < (sizeof(ProfileCategoryPrimitiveType) * 8), "The number of profile categories must not exceed the number of bits in ProfileCategoryPrimitiveType");
-
-        /**
-        * Parallel array to ProfileCategory as string category names to be used as Driller category names or for debug purposes
-        */
-        static const char * ProfileCategoryNames[] =
-        {
-            "Any",
-            "Renderer",
-            "3DEngine",
-            "Particle",
-            "AI",
-            "Animation",
-            "Movie",
-            "Entity",
-            "Font",
-            "Network",
-            "Physics",
-            "Script",
-            "ScriptCFunc",
-            "Audio",
-            "Editor",
-            "System",
-            "Action",
-            "Game",
-            "Input",
-            "Sync",
-
-            "LegacyNetworkTrafficReserved",
-            "LegacyDeviceReserved",
-
-            "LegacyLast",
-
-            "AzTrace",
-            "AzCore",
-            "AzRender",
-            "AzFramework",
-            "AzToolsFramework",
-            "ScriptCanvas",
-            "LegacyTerrain",
-            "Terrain",
-            "Cloth",
-
-            "RendererDetailed",
-            "3DEngineDetailed",
-            "JobManagerDetailed",
-            "AzRenderDetailed",
-            "ClothDetailed",
-
-            "MemoryReserved",
-            "Global"
-        };
-        static_assert(AZ_ARRAY_SIZE(ProfileCategoryNames) == static_cast<size_t>(ProfileCategory::Count), "ProfileCategory and ProfileCategoryNames size mismatch");
-    }
-}
-
-// Must be included below ProfileCategory 
 #ifdef AZ_PROFILE_TELEMETRY
 #   include <RADTelemetry/ProfileTelemetry.h>
 #endif
 
 #if defined(AZ_PROFILER_MACRO_DISABLE) // by default we never disable the profiler registers as their overhead should be minimal, you can still do that for your code though.
-#   define AZ_PROFILE_TIMER(...)
-#   define AZ_PROFILE_TIMER_END(_SectionVariableName)
-#   define AZ_PROFILE_VALUE_SET(...)
-#   define AZ_PROFILE_VALUE_ADD(...)
-#   define AZ_PROFILE_VALUE_SET_NAMED(...)
-#   define AZ_PROFILE_VALUE_ADD_NAMED(...)
+#   define AZ_PROFILE_SCOPE(...)
+#   define AZ_PROFILE_FUNCTION(...)
+#   define AZ_PROFILE_BEGIN(...)
+#   define AZ_PROFILE_END(...)
 #else
-/// Implementation when we have only 1 param system name
-#   define AZ_PROFILE_TIMER_1(_1)     AZ_PROFILE_TIMER_2(_1, nullptr)
-/// Implementation when we have 2 params (_1 system name and _2 is name of the "section"/register/profiled section - used for debug)
-#   define AZ_PROFILE_TIMER_2(_1, _2)  AZ_PROFILE_TIMER_3(_1, _2, AZ_JOIN(azProfileSection, __LINE__))
-/// Implementation when we have all 3 params (system name, section/register name, section variable name)
-#   define AZ_PROFILE_TIMER_3(_1, _2, _3)                                                                                                                     \
-    AZ::Debug::ProfilerSection _3;                                                                                                                            \
-    if (AZ::u64 profilerId = AZ::Debug::Profiler::GetId()) {                                                                                                  \
-        static AZ_THREAD_LOCAL AZ::Internal::RegisterData AZ_JOIN(azProfileRegister, __LINE__) = {0, 0};                                                      \
-        if (AZ_JOIN(azProfileRegister, __LINE__).m_profilerId != profilerId) {                                                                                \
-            AZ_JOIN(azProfileRegister, __LINE__).m_register = AZ::Debug::ProfilerRegister::TimerCreateAndStart(_1, _2, &_3, AZ_FUNCTION_SIGNATURE, __LINE__); \
-            AZ_JOIN(azProfileRegister, __LINE__).m_profilerId = profilerId;                                                                                   \
-        } else {                                                                                                                                              \
-            AZ_JOIN(azProfileRegister, __LINE__).m_register->TimerStart(&_3);                                                                                 \
-        }                                                                                                                                                     \
-    }
-
 /**
  * Macro to declare a profile section for the current scope { }.
- * format is: AZ_PROFILE_TIMER(const char* systemName, const char* sectionDescription = nullptr , optional sectionName )
- * \param _1 is required and it's 'const char*' of the system name of which system this scope/register belongs to.
- * \param _2 is optional and it's 'const char*' with a name for the "section"/register/profiled section - used as description. If not provided a "Anonymous" will be set.
- * \param _3 is optional unique name for a section C++ variable (so you can stop the SCOPE as you wish). If not provided a default unique name is created.
+ * format is: AZ_PROFILE_SCOPE(categoryName, const char* formatStr, ...)
  */
-#   define AZ_PROFILE_TIMER(...)        AZ_MACRO_SPECIALIZE(AZ_PROFILE_TIMER_, AZ_VA_NUM_ARGS(__VA_ARGS__), (__VA_ARGS__))
-
-// Optional (USE ONLY IN EXTREME CASES!!!) scope end command for named sections, so you stop the profiler register timing before it goes out of scope.
-#   define AZ_PROFILE_TIMER_END(_SectionVariableName)  { _SectionVariableName.Stop(); }
-
-/**
- * Macro to operate on custom values. All values are AZ::s64. You can provide up to 5 values.
- * format is AZ_PROFILE_VALUE_SET/ADD(const char* systemName, const char* valueName,
- * value1, optional value2, optional value3, optional value 4, optional value5, optional registerName (for direct register manipulation for EXPERTS ONLY)).
- * \param _SystemName is required and it's 'const char*' of the system name of which system this scope/register belongs to.
- * \param _RegisterName is required and it's 'const char*' with a name for the register - used as description.
- * \param 3 is required and it's AZ::s64, operates on m_value1.
- * \param 4 is optional and it's AZ::s64, operates on m_value2.
- * \param 5 is optional and it's AZ::s64, operates on m_value3.
- * \param 6 is optional and it's AZ::s64, operates on m_value4.
- * \param 7 is optional and it's AZ::s64, operates on m_value5.
- */
-#   define AZ_PROFILE_VALUE_SET(_SystemName, _RegisterName, ...)                                                                                                     \
-    if (AZ::u64 profilerId = AZ::Debug::Profiler::GetId()) {                                                                                                         \
-        static AZ_THREAD_LOCAL AZ::Internal::RegisterData AZ_JOIN(azProfileRegister, __LINE__) = {0, 0};                                                             \
-        if (AZ_JOIN(azProfileRegister, __LINE__).m_profilerId != profilerId) {                                                                                       \
-            AZ_JOIN(azProfileRegister, __LINE__).m_register = AZ::Debug::ProfilerRegister::ValueCreate(_SystemName, _RegisterName, AZ_FUNCTION_SIGNATURE, __LINE__); \
-            AZ_JOIN(azProfileRegister, __LINE__).m_profilerId = profilerId;                                                                                          \
-        }                                                                                                                                                            \
-        AZ_JOIN(azProfileRegister, __LINE__).m_register->ValueSet(__VA_ARGS__);                                                                                      \
-    }
-
-/// Same as AZ_PROFILE_VALUE_SET except is add the values passed in the macro (you can use -(value), to subtract values)
-#   define AZ_PROFILE_VALUE_ADD(_SystemName, _RegisterName, ...)                                                                                                     \
-    if (AZ::u64 profilerId = AZ::Debug::Profiler::GetId()) {                                                                                                         \
-        static AZ_THREAD_LOCAL AZ::Internal::RegisterData AZ_JOIN(azProfileRegister, __LINE__) = {0, 0};                                                             \
-        if (AZ_JOIN(azProfileRegister, __LINE__).m_profilerId != profilerId) {                                                                                       \
-            AZ_JOIN(azProfileRegister, __LINE__).m_register = AZ::Debug::ProfilerRegister::ValueCreate(_SystemName, _RegisterName, AZ_FUNCTION_SIGNATURE, __LINE__); \
-            AZ_JOIN(azProfileRegister, __LINE__).m_profilerId = profilerId;                                                                                          \
-        }                                                                                                                                                            \
-        AZ_JOIN(azProfileRegister, __LINE__).m_register->ValueAdd(__VA_ARGS__);                                                                                      \
-    }
-
-/**
- * Same as AZ_PROFILER_VALUE_SET but with option to access the register by name. (USE ONLY IN EXTREME CASES!!!)
- * \param _RegisterVaribaleName is optional unique name for a register C++ variable so you can manipulate the register.
- */
-#   define AZ_PROFILE_VALUE_SET_NAMED(_SystemName, _RegisterName, _RegisterVaribaleName, ...)                                                                        \
-    AZ::Debug::ProfilerRegister * _RegisterVaribaleName = nullptr;                                                                                                   \
-    if (AZ::u64 profilerId = AZ::Debug::Profiler::GetId()) {                                                                                                         \
-        static AZ_THREAD_LOCAL AZ::Internal::RegisterData AZ_JOIN(azProfileRegister, __LINE__) = {0, 0};                                                             \
-        if (AZ_JOIN(azProfileRegister, __LINE__).m_profilerId != profilerId) {                                                                                       \
-            AZ_JOIN(azProfileRegister, __LINE__).m_register = AZ::Debug::ProfilerRegister::ValueCreate(_SystemName, _RegisterName, AZ_FUNCTION_SIGNATURE, __LINE__); \
-            AZ_JOIN(azProfileRegister, __LINE__).m_profilerId = profilerId;                                                                                          \
-        }                                                                                                                                                            \
-        AZ_JOIN(azProfileRegister, __LINE__).m_register->ValueSet(__VA_ARGS__);                                                                                      \
-        _RegisterVaribaleName = AZ_JOIN(azProfileRegister, __LINE__).m_register;                                                                                     \
-    }
-
-/// Same as AZ_PROFILE_VALUE_SET_NAMED but add the values to the current. (USE ONLY IN EXTREME CASES!!!)
-#   define AZ_PROFILE_VALUE_ADD_NAMED(_SystemName, _RegisterName, _RegisterVaribaleName, ...)                                                                        \
-    AZ::Debug::ProfilerRegister * _RegisterVaribaleName = nullptr;                                                                                                   \
-    if (AZ::u64 profilerId = AZ::Debug::Profiler::GetId()) {                                                                                                         \
-        static AZ_THREAD_LOCAL AZ::Internal::RegisterData AZ_JOIN(azProfileRegister, __LINE__) = {0, 0};                                                             \
-        if (AZ_JOIN(azProfileRegister, __LINE__).m_profilerId != profilerId) {                                                                                       \
-            AZ_JOIN(azProfileRegister, __LINE__).m_register = AZ::Debug::ProfilerRegister::ValueCreate(_SystemName, _RegisterName, AZ_FUNCTION_SIGNATURE, __LINE__); \
-            AZ_JOIN(azProfileRegister, __LINE__).m_profilerId = profilerId;                                                                                          \
-        }                                                                                                                                                            \
-        AZ_JOIN(azProfileRegister, __LINE__).m_register->ValueAdd(__VA_ARGS__);                                                                                      \
-        _RegisterVaribaleName = AZ_JOIN(azProfileRegister, __LINE__).m_register;                                                                                     \
-    }
+#   define AZ_PROFILE_SCOPE(category, formatStr, ...) ::AZ::ProfileScope AZ_JOIN(azProfileScope, __LINE__){ #category, formatStr, __VA_ARGS__ }
+#   define AZ_PROFILE_FUNCTION(category) AZ_PROFILE_SCOPE(category, AZ_FUNCTION_SIGNATURE)
 
+// Prefer using the scoped macros which automatically end the event (AZ_PROFILE_SCOPE/AZ_PROFILE_FUNCTION)
+#   define AZ_PROFILE_BEGIN(category, name, ...) ::AZ::ProfileScope::BeginRegion(#category, name, __VA_ARGS__)
+#   define AZ_PROFILE_END() ::AZ::ProfileScope::EndRegion()
 #endif // AZ_PROFILER_MACRO_DISABLE
 
-#ifndef AZ_PROFILE_FUNCTION
-// No other profiler has defined the performance markers AZ_PROFILE_SCOPE (and friends), fallback to a Driller implementation
-#   define AZ_INTERNAL_PROF_VERIFY_CAT(category) static_assert(category < AZ::Debug::ProfileCategory::Count, "Invalid profile category")
-#   define AZ_INTERNAL_PROF_CAT_NAME(category) AZ::Debug::ProfileCategoryNames[static_cast<AZ::u32>(category)]
-
-#   define AZ_PROFILE_FUNCTION(category) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_PROFILE_TIMER(AZ_INTERNAL_PROF_CAT_NAME(category))
-#   define AZ_PROFILE_FUNCTION_STALL(category) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_PROFILE_TIMER(AZ_INTERNAL_PROF_CAT_NAME(category))
-#   define AZ_PROFILE_FUNCTION_IDLE(category) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_PROFILE_TIMER(AZ_INTERNAL_PROF_CAT_NAME(category))
-
-#   define AZ_PROFILE_SCOPE(category, name) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_PROFILE_TIMER(AZ_INTERNAL_PROF_CAT_NAME(category)); (void)(name)
-#   define AZ_PROFILE_SCOPE_STALL(category, name) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_PROFILE_TIMER(AZ_INTERNAL_PROF_CAT_NAME(category)); (void)(name)
-#   define AZ_PROFILE_SCOPE_IDLE(category, name) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_PROFILE_TIMER(AZ_INTERNAL_PROF_CAT_NAME(category)); (void)(name)
-
-#   define AZ_PROFILE_SCOPE_DYNAMIC(category, ...) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_PROFILE_TIMER(AZ_INTERNAL_PROF_CAT_NAME(category))
-#   define AZ_PROFILE_SCOPE_STALL_DYNAMIC(category, ...) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_PROFILE_TIMER(AZ_INTERNAL_PROF_CAT_NAME(category))
-#   define AZ_PROFILE_SCOPE_IDLE_DYNAMIC(category, ...) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_PROFILE_TIMER(AZ_INTERNAL_PROF_CAT_NAME(category))
-#endif
-
-#ifndef AZ_PROFILE_EVENT_BEGIN
-// No other profiler has defined the performance markers AZ_PROFILE_EVENT_START/END, fallback to a Driller implementation (currently empty)
-#   define AZ_PROFILE_EVENT_BEGIN(category, name) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); (void)(name)
-#   define AZ_PROFILE_EVENT_END(category) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category)
-#endif
-
 #ifndef AZ_PROFILE_INTERVAL_START
 // No other profiler has defined the performance markers AZ_PROFILE_INTERVAL_START/END, fallback to a Driller implementation (currently empty)
-#   define AZ_INTERNAL_PROF_VERIFY_INTERVAL_ID(id) static_assert(sizeof(id) <= sizeof(AZ::u64), "Interval id must be a unique value no larger than 64-bits")
-#   define AZ_PROFILE_INTERVAL_START(category, id, ...) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_INTERNAL_PROF_VERIFY_INTERVAL_ID(id)
-#   define AZ_PROFILE_INTERVAL_START_COLORED(category, id, color, ...) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); (void)(color); AZ_INTERNAL_PROF_VERIFY_INTERVAL_ID(id)
-#   define AZ_PROFILE_INTERVAL_END(category, id) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_INTERNAL_PROF_VERIFY_INTERVAL_ID(id)
-#   define AZ_PROFILE_INTERVAL_SCOPED(category, id, ...) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_INTERNAL_PROF_VERIFY_INTERVAL_ID(id)
+#   define AZ_PROFILE_INTERVAL_START(...)
+#   define AZ_PROFILE_INTERVAL_START_COLORED(...)
+#   define AZ_PROFILE_INTERVAL_END(...)
+#   define AZ_PROFILE_INTERVAL_SCOPED(...)
 #endif
 
 #ifndef AZ_PROFILE_DATAPOINT
 // No other profiler has defined the performance markers AZ_PROFILE_DATAPOINT, fallback to a Driller implementation (currently empty)
-#define AZ_PROFILE_DATAPOINT(category, value, ...) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); static_cast<double>(value)
-#define AZ_PROFILE_DATAPOINT_PERCENT(category, value, ...) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); static_cast<double>(value)
-#endif
-
-#ifndef AZ_PROFILE_MEMORY_ALLOC
-// No other profiler has defined the performance markers AZ_PROFILE_MEMORY_ALLOC (and friends), fall back to a Driller implementation (currently empty)
-#   define AZ_PROFILE_MEMORY_ALLOC(category, address, size, context) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); (void)(context)
-#   define AZ_PROFILE_MEMORY_ALLOC_EX(category, filename, lineNumber, address, size, context) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); (void)(context)
-#   define AZ_PROFILE_MEMORY_FREE(category, address) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category)
-#   define AZ_PROFILE_MEMORY_FREE_EX(category, filename, lineNumber, address) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category)
+#   define AZ_PROFILE_DATAPOINT(...)
+#   define AZ_PROFILE_DATAPOINT_PERCENT(...)
 #endif
 
 namespace AZStd
@@ -317,6 +61,43 @@ namespace AZStd
 
 namespace AZ
 {
+    class ProfileScope
+    {
+    public:
+        static uint32_t GetSystemID(const char* system);
+
+        template<typename... T>
+        static void BeginRegion(const char* system, char const* eventName, [[maybe_unused]] T const&... args)
+        {
+            // TODO: Verification that the supplied system name corresponds to a known budget
+#if defined(USE_PIX)
+            PIXBeginEvent(PIX_COLOR_INDEX(GetSystemID(system) & 0xff), eventName, args...);
+#else
+            (void)system;
+            (void)eventName;
+#endif
+            // TODO: injecting instrumentation for other profilers
+        }
+
+        static void EndRegion()
+        {
+#if defined(USE_PIX)
+            PIXEndEvent();
+#endif
+        }
+
+        template<typename... T>
+        ProfileScope(const char* system, char const* eventName, T const&... args)
+        {
+            BeginRegion(system, eventName, args...);
+        }
+
+        ~ProfileScope()
+        {
+            EndRegion();
+        }
+    };
+
     namespace Debug
     {
         class ProfilerSection;
diff --git a/Code/Framework/AzCore/AzCore/IO/FileIO.cpp b/Code/Framework/AzCore/AzCore/IO/FileIO.cpp
index 125951c261..a6ce8cf101 100644
--- a/Code/Framework/AzCore/AzCore/IO/FileIO.cpp
+++ b/Code/Framework/AzCore/AzCore/IO/FileIO.cpp
@@ -13,6 +13,7 @@
 #include <AzCore/std/string/wildcard.h>
 #include <AzCore/std/containers/array.h>
 #include <AzCore/PlatformIncl.h>
+#include <AzCore/Debug/Profiler.h>
 
 #ifndef SEEK_SET
 #  define SEEK_SET        0       /* Seek from beginning of file.  */
@@ -353,7 +354,7 @@ namespace AZ
                 m_filename = path;
             }
 
-            AZ_PROFILE_INTERVAL_START_COLORED(AZ::Debug::ProfileCategory::AzCore, &m_filename, 0xff0000ff, "FileIO: %s", m_filename.c_str());
+            AZ_PROFILE_INTERVAL_START_COLORED(AzCore, &m_filename, 0xff0000ff, "FileIO: %s", m_filename.c_str());
             return result;
         }
 
@@ -372,7 +373,7 @@ namespace AZ
                 FileIOBase::GetInstance()->Close(m_handle);
                 m_handle = InvalidHandle;
                 m_ownsHandle = false;
-                AZ_PROFILE_INTERVAL_END(AZ::Debug::ProfileCategory::AzCore, &m_filename);
+                AZ_PROFILE_INTERVAL_END(AzCore, &m_filename);
             }
         }
 
@@ -425,7 +426,7 @@ namespace AZ
 
         void FileIOStream::Seek(OffsetType bytes, SeekMode mode)
         {
-            AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "FileIO Seek: %s", m_filename.c_str());
+            AZ_PROFILE_SCOPE(AzCore, "FileIO Seek: %s", m_filename.c_str());
             AZ_Assert(FileIOBase::GetInstance(), "FileIO is not initialized.");
             AZ_Assert(IsOpen(), "Cannot seek on a FileIOStream that is not open.");
 
@@ -453,7 +454,7 @@ namespace AZ
 
         SizeType FileIOStream::Read(SizeType bytes, void* oBuffer)
         {
-            AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "FileIO Read: %s", m_filename.c_str());
+            AZ_PROFILE_SCOPE(AzCore, "FileIO Read: %s", m_filename.c_str());
             AZ_Assert(FileIOBase::GetInstance(), "FileIO is not initialized.");
             AZ_Assert(IsOpen(), "Cannot read from a FileIOStream that is not open.");
 
diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/BlockCache.cpp b/Code/Framework/AzCore/AzCore/IO/Streamer/BlockCache.cpp
index f358370be5..09ab10b8cf 100644
--- a/Code/Framework/AzCore/AzCore/IO/Streamer/BlockCache.cpp
+++ b/Code/Framework/AzCore/AzCore/IO/Streamer/BlockCache.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <AzCore/Casting/numeric_cast.h>
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/IO/Streamer/BlockCache.h>
 #include <AzCore/IO/Streamer/FileRequest.h>
 #include <AzCore/IO/Streamer/StreamerContext.h>
@@ -245,7 +246,7 @@ namespace AZ
 
             auto continueReadFile = [this, request](FileRequest& fileSizeRequest)
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+                AZ_PROFILE_FUNCTION(AzCore);
                 AZ_Assert(m_numMetaDataRetrievalInProgress > 0,
                     "More requests have completed meta data retrieval in the Block Cache than were requested.");
                 m_numMetaDataRetrievalInProgress--;
@@ -454,7 +455,7 @@ namespace AZ
                         section.m_readSize, sharedRead);
                     readRequest->SetCompletionCallback([this](FileRequest& request)
                         {
-                            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+                            AZ_PROFILE_FUNCTION(AzCore);
                             CompleteRead(request);
                         });
                     section.m_cacheBlockIndex = cacheLocation;
diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/FullFileDecompressor.cpp b/Code/Framework/AzCore/AzCore/IO/Streamer/FullFileDecompressor.cpp
index 2e9dd43e83..44bf36bd9d 100644
--- a/Code/Framework/AzCore/AzCore/IO/Streamer/FullFileDecompressor.cpp
+++ b/Code/Framework/AzCore/AzCore/IO/Streamer/FullFileDecompressor.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <AzCore/Casting/numeric_cast.h>
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/IO/CompressionBus.h>
 #include <AzCore/IO/Streamer/FileRequest.h>
 #include <AzCore/IO/Streamer/FullFileDecompressor.h>
@@ -367,7 +368,7 @@ namespace AZ
                 {
                     auto callback = [this, nextRequest](const FileRequest& checkRequest)
                     {
-                        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+                        AZ_PROFILE_FUNCTION(AzCore);
                         auto check = AZStd::get_if<FileRequest::FileExistsCheckData>(&checkRequest.GetCommand());
                         AZ_Assert(check,
                             "Callback in FullFileDecompressor::PrepareReadRequest expected FileExistsCheck but got another command.");
@@ -426,7 +427,7 @@ namespace AZ
                 {
                     auto callback = [this, nextRequest](const FileRequest& checkRequest)
                     {
-                        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+                        AZ_PROFILE_FUNCTION(AzCore);
                         auto check = AZStd::get_if<FileRequest::FileExistsCheckData>(&checkRequest.GetCommand());
                         AZ_Assert(check,
                             "Callback in FullFileDecompressor::PrepareDedicatedCache expected FileExistsCheck but got another command.");
@@ -508,7 +509,7 @@ namespace AZ
                     archiveReadRequest->SetCompletionCallback(
                         [this, readSlot = i](FileRequest& request)
                         {
-                            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+                            AZ_PROFILE_FUNCTION(AzCore);
                             FinishArchiveRead(&request, readSlot);
                         });
                     m_next->QueueRequest(archiveReadRequest);
@@ -596,7 +597,7 @@ namespace AZ
 
                     waitRequest->SetCompletionCallback([this, jobSlot](FileRequest& request)
                         {
-                            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+                            AZ_PROFILE_FUNCTION(AzCore);
                             FinishDecompression(&request, jobSlot);
                         });
 
diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/ReadSplitter.cpp b/Code/Framework/AzCore/AzCore/IO/Streamer/ReadSplitter.cpp
index 9e019745a3..00c1c63933 100644
--- a/Code/Framework/AzCore/AzCore/IO/Streamer/ReadSplitter.cpp
+++ b/Code/Framework/AzCore/AzCore/IO/Streamer/ReadSplitter.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <AzCore/Casting/numeric_cast.h>
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/IO/Streamer/FileRequest.h>
 #include <AzCore/IO/Streamer/ReadSplitter.h>
 #include <AzCore/IO/Streamer/StreamerContext.h>
@@ -218,7 +219,7 @@ namespace AZ
                 subRequest->CreateRead(pending.m_request, pending.m_output, bufferSize, data->m_path, pending.m_offset, readSize, data->m_sharedRead);
                 subRequest->SetCompletionCallback([this](FileRequest&)
                     {
-                        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+                        AZ_PROFILE_FUNCTION(AzCore);
                         QueuePendingRequest();
                     });
                 m_next->QueueRequest(subRequest);
@@ -302,7 +303,7 @@ namespace AZ
                         offset, readSize, data->m_sharedRead);
                     subRequest->SetCompletionCallback([this, bufferSlot]([[maybe_unused]] FileRequest& request)
                         {
-                            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+                            AZ_PROFILE_FUNCTION(AzCore);
 
                             BufferCopyInformation& copyInfo = m_bufferCopyInformation[bufferSlot];
                             memcpy(copyInfo.m_target, GetBufferSlot(bufferSlot) + copyInfo.m_bufferOffset, copyInfo.m_size);
diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/Scheduler.cpp b/Code/Framework/AzCore/AzCore/IO/Streamer/Scheduler.cpp
index d6e5a7bb2c..e7f9b0fd18 100644
--- a/Code/Framework/AzCore/AzCore/IO/Streamer/Scheduler.cpp
+++ b/Code/Framework/AzCore/AzCore/IO/Streamer/Scheduler.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <AzCore/Casting/numeric_cast.h>
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/IO/Streamer/Scheduler.h>
 #include <AzCore/std/containers/deque.h>
 #include <AzCore/std/sort.h>
@@ -138,14 +139,14 @@ namespace AZ::IO
         while (m_isRunning)
         {
             {
-                AZ_PROFILE_SCOPE_IDLE(AZ::Debug::ProfileCategory::AzCore, "Scheduler suspended.");
+                AZ_PROFILE_SCOPE(AzCore, "Scheduler suspended.");
                 m_context.SuspendSchedulingThread();
             }
 
             // Only do processing if the thread hasn't been suspended.
             while (!m_isSuspended)
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "Scheduler main loop.");
+                AZ_PROFILE_SCOPE(AzCore, "Scheduler main loop.");
 
                 // Always schedule requests first as the main Streamer thread could have been asleep for a long time due to slow reading
                 // but also don't schedule after every change in the queue as scheduling is not cheap.
@@ -154,7 +155,7 @@ namespace AZ::IO
                 {
                     do
                     {
-                        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "Scheduler queue requests.");
+                        AZ_PROFILE_SCOPE(AzCore, "Scheduler queue requests.");
                         // If there are pending requests and available slots, queue the next requests.
                         while(m_context.GetNumPreparedRequests() > 0)
                         {
@@ -208,7 +209,7 @@ namespace AZ::IO
 
     void Scheduler::Thread_QueueNextRequest()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         FileRequest* next = m_context.PopPreparedRequest();
         next->SetStatus(IStreamerTypes::RequestStatus::Processing);
@@ -279,7 +280,7 @@ namespace AZ::IO
                     m_processingSize += info.m_uncompressedSize;
 #endif
                 }
-                AZ_PROFILE_INTERVAL_START_COLORED(AZ::Debug::ProfileCategory::AzCore, next, ProfilerColor,
+                AZ_PROFILE_INTERVAL_START_COLORED(AzCore, next, ProfilerColor,
                     "Streamer queued %zu: %s", next->GetCommand().index(), parentReadRequest->m_path.GetRelativePath());
                 m_threadData.m_streamStack->QueueRequest(next);
             }
@@ -293,7 +294,7 @@ namespace AZ::IO
             }
             else if constexpr (AZStd::is_same_v<Command, FileRequest::FlushData> || AZStd::is_same_v<Command, FileRequest::FlushAllData>)
             {
-                AZ_PROFILE_INTERVAL_START_COLORED(AZ::Debug::ProfileCategory::AzCore, next, ProfilerColor,
+                AZ_PROFILE_INTERVAL_START_COLORED(AzCore, next, ProfilerColor,
                     "Streamer queued %zu", next->GetCommand().index());
                 // Flushing becomes a lot less complicated if there are no jobs and/or asynchronous I/O running. This does mean overall
                 // longer processing time as bubbles are introduced into the pipeline, but flushing is an infrequent event that only
@@ -303,7 +304,7 @@ namespace AZ::IO
             }
             else
             {
-                AZ_PROFILE_INTERVAL_START_COLORED(AZ::Debug::ProfileCategory::AzCore, next, ProfilerColor,
+                AZ_PROFILE_INTERVAL_START_COLORED(AzCore, next, ProfilerColor,
                     "Streamer queued %zu", next->GetCommand().index());
                 m_threadData.m_streamStack->QueueRequest(next);
             }
@@ -312,13 +313,13 @@ namespace AZ::IO
 
     bool Scheduler::Thread_ExecuteRequests()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
         return m_threadData.m_streamStack->ExecuteRequests();
     }
 
     bool Scheduler::Thread_PrepareRequests(AZStd::vector<FileRequestPtr>& outstandingRequests)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         {
             AZStd::scoped_lock lock(m_pendingRequestsLock);
@@ -372,7 +373,7 @@ namespace AZ::IO
 
     void Scheduler::Thread_ProcessTillIdle()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         while (true)
         {
@@ -390,7 +391,7 @@ namespace AZ::IO
 
     void Scheduler::Thread_ProcessCancelRequest(FileRequest* request, FileRequest::CancelData& data)
     {
-        AZ_PROFILE_INTERVAL_START_COLORED(AZ::Debug::ProfileCategory::AzCore, request, ProfilerColor, "Streamer queued cancel");
+        AZ_PROFILE_INTERVAL_START_COLORED(AzCore, request, ProfilerColor, "Streamer queued cancel");
         auto& pending = m_context.GetPreparedRequests();
         auto pendingIt = pending.begin();
         while (pendingIt != pending.end())
@@ -412,7 +413,7 @@ namespace AZ::IO
 
     void Scheduler::Thread_ProcessRescheduleRequest(FileRequest* request, FileRequest::RescheduleData& data)
     {
-        AZ_PROFILE_INTERVAL_START_COLORED(AZ::Debug::ProfileCategory::AzCore, request, ProfilerColor, "Streamer queued reschedule");
+        AZ_PROFILE_INTERVAL_START_COLORED(AzCore, request, ProfilerColor, "Streamer queued reschedule");
         auto& pendingRequests = m_context.GetPreparedRequests();
         for (FileRequest* pending : pendingRequests)
         {
@@ -543,7 +544,7 @@ namespace AZ::IO
 
     void Scheduler::Thread_ScheduleRequests()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         AZStd::chrono::system_clock::time_point now = AZStd::chrono::system_clock::now();
         auto& pendingQueue = m_context.GetPreparedRequests();
@@ -554,7 +555,7 @@ namespace AZ::IO
 
         if (m_context.GetNumPreparedRequests() > 1)
         {
-            AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore,
+            AZ_PROFILE_SCOPE(AzCore,
                 "Scheduler::Thread_ScheduleRequests - Sorting %i requests", m_context.GetNumPreparedRequests());
             auto sorter = [this](const FileRequest* lhs, const FileRequest* rhs) -> bool
             {
diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/Statistics.cpp b/Code/Framework/AzCore/AzCore/IO/Streamer/Statistics.cpp
index 593c052853..e64c3cae74 100644
--- a/Code/Framework/AzCore/AzCore/IO/Streamer/Statistics.cpp
+++ b/Code/Framework/AzCore/AzCore/IO/Streamer/Statistics.cpp
@@ -48,7 +48,7 @@ namespace AZ
             [[maybe_unused]] AZStd::string_view name,
             [[maybe_unused]] double value)
         {
-            AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::AzCore, value,
+            AZ_PROFILE_DATAPOINT(AzCore, value,
                 "Streamer/%.*s/%.*s (Raw)",
                 aznumeric_cast<int>(owner.size()), owner.data(),
                 aznumeric_cast<int>(name.size()), name.data());
diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/StorageDrive.cpp b/Code/Framework/AzCore/AzCore/IO/Streamer/StorageDrive.cpp
index c4f9840a0b..6f33c0a216 100644
--- a/Code/Framework/AzCore/AzCore/IO/Streamer/StorageDrive.cpp
+++ b/Code/Framework/AzCore/AzCore/IO/Streamer/StorageDrive.cpp
@@ -59,7 +59,7 @@ namespace AZ
 
         void StorageDrive::PrepareRequest(FileRequest* request)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
             AZ_Assert(request, "PrepareRequest was provided a null request.");
 
             if (AZStd::holds_alternative<FileRequest::ReadRequestData>(request->GetCommand()))
@@ -254,7 +254,7 @@ namespace AZ
 
         void StorageDrive::ReadFile(FileRequest* request)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             auto data = AZStd::get_if<FileRequest::ReadData>(&request->GetCommand());
             AZ_Assert(data, "FileRequest queued on StorageDrive to be read didn't contain read data.");
@@ -341,7 +341,7 @@ namespace AZ
 
         void StorageDrive::FileExistsRequest(FileRequest* request)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
             TIMED_AVERAGE_WINDOW_SCOPE(m_getFileExistsTimeAverage);
 
             auto& fileExists = AZStd::get<FileRequest::FileExistsCheckData>(request->GetCommand());
@@ -359,7 +359,7 @@ namespace AZ
 
         void StorageDrive::FileMetaDataRetrievalRequest(FileRequest* request)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
             TIMED_AVERAGE_WINDOW_SCOPE(m_getFileMetaDataTimeAverage);
 
             auto& command = AZStd::get<FileRequest::FileMetaDataRetrievalData>(request->GetCommand());
diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/Streamer.cpp b/Code/Framework/AzCore/AzCore/IO/Streamer/Streamer.cpp
index 792ef8ea1e..e634f2eac8 100644
--- a/Code/Framework/AzCore/AzCore/IO/Streamer/Streamer.cpp
+++ b/Code/Framework/AzCore/AzCore/IO/Streamer/Streamer.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <AzCore/Casting/numeric_cast.h>
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/IO/CompressionBus.h>
 #include <AzCore/IO/Streamer/Streamer.h>
 #include <AzCore/IO/Streamer/StreamerConfiguration.h>
@@ -262,15 +263,15 @@ namespace AZ::IO
             switch (stat.GetType())
             {
             case Statistic::Type::FloatingPoint:
-                AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::AzCore, stat.GetFloatValue(), "Streamer/%.*s/%.*s",
+                AZ_PROFILE_DATAPOINT(AzCore, stat.GetFloatValue(), "Streamer/%.*s/%.*s",
                     aznumeric_cast<int>(stat.GetOwner().length()), stat.GetOwner().data(), aznumeric_cast<int>(stat.GetName().length()), stat.GetName().data());
                 break;
             case Statistic::Type::Integer:
-                AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::AzCore, stat.GetIntegerValue(), "Streamer/%.*s/%.*s",
+                AZ_PROFILE_DATAPOINT(AzCore, stat.GetIntegerValue(), "Streamer/%.*s/%.*s",
                     aznumeric_cast<int>(stat.GetOwner().length()), stat.GetOwner().data(), aznumeric_cast<int>(stat.GetName().length()), stat.GetName().data());
                 break;
             case Statistic::Type::Percentage:
-                AZ_PROFILE_DATAPOINT_PERCENT(AZ::Debug::ProfileCategory::AzCore, stat.GetPercentage(), "Streamer/%.*s/%.*s (percent)",
+                AZ_PROFILE_DATAPOINT_PERCENT(AzCore, stat.GetPercentage(), "Streamer/%.*s/%.*s (percent)",
                     aznumeric_cast<int>(stat.GetOwner().length()), stat.GetOwner().data(), aznumeric_cast<int>(stat.GetName().length()), stat.GetName().data());
                 break;
             default:
diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/StreamerContext.cpp b/Code/Framework/AzCore/AzCore/IO/Streamer/StreamerContext.cpp
index e870e29786..823ab6e050 100644
--- a/Code/Framework/AzCore/AzCore/IO/Streamer/StreamerContext.cpp
+++ b/Code/Framework/AzCore/AzCore/IO/Streamer/StreamerContext.cpp
@@ -153,7 +153,7 @@ namespace AZ
 
         bool StreamerContext::FinalizeCompletedRequests()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
 #if AZ_STREAMER_ADD_EXTRA_PROFILING_INFO
             auto now = AZStd::chrono::system_clock::now();
@@ -218,10 +218,10 @@ namespace AZ
                     bool isInternal = top->m_usage == FileRequest::Usage::Internal;
 
                     {
-                        AZ_PROFILE_SCOPE_STALL(AZ::Debug::ProfileCategory::AzCore,
+                        AZ_PROFILE_SCOPE(AzCore,
                             isInternal ? "Completion callback internal" : "Completion callback external");
                         top->m_onCompletion(*top);
-                        AZ_PROFILE_INTERVAL_END(AZ::Debug::ProfileCategory::AzCore, top);
+                        AZ_PROFILE_INTERVAL_END(AzCore, top);
                     }
                     
                     if (parent)
diff --git a/Code/Framework/AzCore/AzCore/IO/SystemFile.cpp b/Code/Framework/AzCore/AzCore/IO/SystemFile.cpp
index d98b7e1d36..8de8b6b70f 100644
--- a/Code/Framework/AzCore/AzCore/IO/SystemFile.cpp
+++ b/Code/Framework/AzCore/AzCore/IO/SystemFile.cpp
@@ -9,7 +9,6 @@
 #include <AzCore/IO/SystemFile.h>
 #include <AzCore/IO/FileIO.h>
 #include <AzCore/IO/FileIOEventBus.h>
-#include <AzCore/Debug/Profiler.h>
 
 #include <AzCore/PlatformIncl.h>
 #include <AzCore/std/functional.h>
@@ -97,9 +96,6 @@ SystemFile& SystemFile::operator=(SystemFile&& other)
 
 bool SystemFile::Open(const char* fileName, int mode, int platformFlags)
 {
-    AZ_PROFILE_INTERVAL_SCOPED(AZ::Debug::ProfileCategory::AzCore, this, "SystemFile::Open - %s", fileName);
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Open - %s", fileName);
-
     if (fileName)       // If we reopen the file we are allowed to have NULL file name
     {
         if (strlen(fileName) > m_fileName.max_size())
@@ -136,9 +132,6 @@ bool SystemFile::ReOpen(int mode, int platformFlags)
 
 void SystemFile::Close()
 {
-    AZ_PROFILE_INTERVAL_SCOPED(AZ::Debug::ProfileCategory::AzCore, this, "SystemFile::Close - %s", m_fileName.c_str());
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Close - %s", m_fileName.c_str());
-
     if (FileIOBus::HasHandlers())
     {
         bool isHandled = false;
@@ -154,8 +147,6 @@ void SystemFile::Close()
 
 void SystemFile::Seek(SeekSizeType offset, SeekMode mode)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Seek - %s:%i", m_fileName.c_str(), offset);
-
     if (FileIOBus::HasHandlers())
     {
         bool isHandled = false;
@@ -181,16 +172,11 @@ bool SystemFile::Eof()
 
 AZ::u64 SystemFile::ModificationTime()
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::ModTime - %s", m_fileName.c_str());
-
     return Platform::ModificationTime(m_handle, this);
 }
 
 SystemFile::SizeType SystemFile::Read(SizeType byteSize, void* buffer)
 {
-    AZ_PROFILE_INTERVAL_SCOPED(AZ::Debug::ProfileCategory::AzCore, this, "SystemFile::Read - %s:%i", m_fileName.c_str(), byteSize);
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Read - %s:%i", m_fileName.c_str(), byteSize);
-
     if (FileIOBus::HasHandlers())
     {
         SizeType numRead = 0;
@@ -207,9 +193,6 @@ SystemFile::SizeType SystemFile::Read(SizeType byteSize, void* buffer)
 
 SystemFile::SizeType SystemFile::Write(const void* buffer, SizeType byteSize)
 {
-    AZ_PROFILE_INTERVAL_SCOPED(AZ::Debug::ProfileCategory::AzCore, this, "SystemFile::Write - %s:%i", m_fileName.c_str(), byteSize);
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Write - %s:%i", m_fileName.c_str(), byteSize);
-
     if (FileIOBus::HasHandlers())
     {
         SizeType numWritten = 0;
@@ -226,15 +209,11 @@ SystemFile::SizeType SystemFile::Write(const void* buffer, SizeType byteSize)
 
 void SystemFile::Flush()
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Flush - %s", m_fileName.c_str());
-
     Platform::Flush(m_handle, this);
 }
 
 SystemFile::SizeType SystemFile::Length() const
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Length - %s", m_fileName.c_str());
-
     return Platform::Length(m_handle, this);
 }
 
@@ -253,36 +232,26 @@ SystemFile::SizeType SystemFile::DiskOffset() const
 
 bool SystemFile::Exists(const char* fileName)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Exists(util) - %s", fileName);
-
     return Platform::Exists(fileName);
 }
 
 void SystemFile::FindFiles(const char* filter, FindFileCB cb)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::FindFiles(util) - %s", filter);
-
     Platform::FindFiles(filter, cb);
 }
 
 AZ::u64 SystemFile::ModificationTime(const char* fileName)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::ModTime(util) - %s", fileName);
-
     return Platform::ModificationTime(fileName);
 }
 
 SystemFile::SizeType SystemFile::Length(const char* fileName)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Length(util) - %s", fileName);
-
     return Platform::Length(fileName);
 }
 
 SystemFile::SizeType SystemFile::Read(const char* fileName, void* buffer, SizeType byteSize, SizeType byteOffset)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Read(util) - %s:[%i,%i]", fileName, byteOffset, byteSize);
-
     SizeType numBytesRead = 0;
     SystemFile f;
     if (f.Open(fileName, SF_OPEN_READ_ONLY))
@@ -305,8 +274,6 @@ SystemFile::SizeType SystemFile::Read(const char* fileName, void* buffer, SizeTy
 
 bool SystemFile::Delete(const char* fileName)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Delete(util) - %s", fileName);
-
     if (!Exists(fileName))
     {
         return false;
@@ -317,8 +284,6 @@ bool SystemFile::Delete(const char* fileName)
 
 bool SystemFile::Rename(const char* sourceFileName, const char* targetFileName, bool overwrite)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Rename(util) - %s", sourceFileName);
-
     if (!Exists(sourceFileName))
     {
         return false;
@@ -329,29 +294,21 @@ bool SystemFile::Rename(const char* sourceFileName, const char* targetFileName,
 
 bool SystemFile::IsWritable(const char* sourceFileName)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::IsWritable(util) - %s", sourceFileName);
-
     return Platform::IsWritable(sourceFileName);
 }
 
 bool SystemFile::SetWritable(const char* sourceFileName, bool writable)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::SetWritable(util) - %s", sourceFileName);
-
     return Platform::SetWritable(sourceFileName, writable);
 }
 
 bool SystemFile::CreateDir(const char* dirName)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::CreateDir(util) - %s", dirName);
-
     return Platform::CreateDir(dirName);
 }
 
 bool SystemFile::DeleteDir(const char* dirName)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::DeleteDir(util) - %s", dirName);
-
     return Platform::DeleteDir(dirName);
 }
 
diff --git a/Code/Framework/AzCore/AzCore/Jobs/Internal/JobManagerBase.cpp b/Code/Framework/AzCore/AzCore/Jobs/Internal/JobManagerBase.cpp
index 130ff8da6b..a17290d8c5 100644
--- a/Code/Framework/AzCore/AzCore/Jobs/Internal/JobManagerBase.cpp
+++ b/Code/Framework/AzCore/AzCore/Jobs/Internal/JobManagerBase.cpp
@@ -23,10 +23,10 @@ void JobManagerBase::Process(Job* job)
     Job* dependent = job->GetDependent();
     bool isDelete = job->IsAutoDelete();
 
-    AZ_PROFILE_INTERVAL_END(AZ::Debug::ProfileCategory::JobManagerDetailed, job);
+    AZ_PROFILE_INTERVAL_END(JobManagerDetailed, job);
     if (!job->IsCancelled())
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "AZ::JobManagerBase::Process Job");
+        AZ_PROFILE_SCOPE(AzCore, "AZ::JobManagerBase::Process Job");
         job->Process();
     }
 
diff --git a/Code/Framework/AzCore/AzCore/Jobs/Internal/JobManagerWorkStealing.cpp b/Code/Framework/AzCore/AzCore/Jobs/Internal/JobManagerWorkStealing.cpp
index bdf137f621..73fb4ecfe8 100644
--- a/Code/Framework/AzCore/AzCore/Jobs/Internal/JobManagerWorkStealing.cpp
+++ b/Code/Framework/AzCore/AzCore/Jobs/Internal/JobManagerWorkStealing.cpp
@@ -122,7 +122,7 @@ void JobManagerWorkStealing::AddPendingJob(Job* job)
     }
 #endif
 
-    AZ_PROFILE_INTERVAL_START(AZ::Debug::ProfileCategory::JobManagerDetailed, job, "AzCore Job Queued Awaiting Execute");
+    AZ_PROFILE_INTERVAL_START(JobManagerDetailed, job, "AzCore Job Queued Awaiting Execute");
 
     if (job->IsCompletion())
     {
@@ -371,7 +371,7 @@ void JobManagerWorkStealing::ProcessJobsInternal(ThreadInfo* info, Job* suspende
                 {
                     //no available work, so go to sleep (or we have already been signaled by another thread and will acquire the semaphore but not actually sleep)
                     info->m_waitEvent.acquire();
-                    AZ_PROFILE_INTERVAL_END(AZ::Debug::ProfileCategory::JobManagerDetailed, info);
+                    AZ_PROFILE_INTERVAL_END(JobManagerDetailed, info);
 
                     if (m_quitRequested)
                     {
@@ -457,7 +457,7 @@ void JobManagerWorkStealing::ProcessJobsInternal(ThreadInfo* info, Job* suspende
             else
             {
                 //attempt to steal a job from another thread's queue
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "JobManagerWorkStealing::ProcessJobsInternal:WorkStealing");
+                AZ_PROFILE_SCOPE(AzCore, "JobManagerWorkStealing::ProcessJobsInternal:WorkStealing");
 
                 unsigned int numStealAttempts = 0;
                 const unsigned int maxStealAttempts = (unsigned int)m_workerThreads.size() * 3; //try every thread a few times before giving up
@@ -674,7 +674,7 @@ inline void JobManagerWorkStealing::ActivateWorker()
                 m_numAvailableWorkers.fetch_sub(1, AZStd::memory_order_acq_rel);
                 // resume the thread execution
 
-                AZ_PROFILE_INTERVAL_START(AZ::Debug::ProfileCategory::JobManagerDetailed, info, "AzCore WakeJobThread %d", info->m_workerId);
+                AZ_PROFILE_INTERVAL_START(JobManagerDetailed, info, "AzCore WakeJobThread %d", info->m_workerId);
                 info->m_waitEvent.release();
                 return;
             }
diff --git a/Code/Framework/AzCore/AzCore/Jobs/JobCompletion.h b/Code/Framework/AzCore/AzCore/Jobs/JobCompletion.h
index 50776a30da..eda03bb5f6 100644
--- a/Code/Framework/AzCore/AzCore/Jobs/JobCompletion.h
+++ b/Code/Framework/AzCore/AzCore/Jobs/JobCompletion.h
@@ -33,7 +33,7 @@ namespace AZ
          */
         void StartAndWaitForCompletion()
         {
-            AZ_PROFILE_FUNCTION_STALL(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             // start the job
             Start();
diff --git a/Code/Framework/AzCore/AzCore/Jobs/LegacyJobExecutor.h b/Code/Framework/AzCore/AzCore/Jobs/LegacyJobExecutor.h
index dd626a9829..8018cf409f 100644
--- a/Code/Framework/AzCore/AzCore/Jobs/LegacyJobExecutor.h
+++ b/Code/Framework/AzCore/AzCore/Jobs/LegacyJobExecutor.h
@@ -72,7 +72,7 @@ namespace AZ
 
             while (m_running)
             {
-                AZ_PROFILE_FUNCTION_STALL(AZ::Debug::ProfileCategory::AzCore);
+                AZ_PROFILE_FUNCTION(AzCore);
                 m_completionCondition.wait(uniqueLock, [this] { return !this->m_running; });
             }
         }
diff --git a/Code/Framework/AzCore/AzCore/Memory/AllocationRecords.cpp b/Code/Framework/AzCore/AzCore/Memory/AllocationRecords.cpp
index fc75f3c37e..7d644c6917 100644
--- a/Code/Framework/AzCore/AzCore/Memory/AllocationRecords.cpp
+++ b/Code/Framework/AzCore/AzCore/Memory/AllocationRecords.cpp
@@ -11,6 +11,7 @@
 #include <AzCore/Memory/AllocatorManager.h>
 #include <AzCore/Driller/DrillerBus.h>
 
+#include <AzCore/std/time.h>
 #include <AzCore/std/parallel/mutex.h>
 
 #include <AzCore/Debug/StackTracer.h>
diff --git a/Code/Framework/AzCore/AzCore/Memory/SimpleSchemaAllocator.h b/Code/Framework/AzCore/AzCore/Memory/SimpleSchemaAllocator.h
index 08e8098dac..e9d001aec3 100644
--- a/Code/Framework/AzCore/AzCore/Memory/SimpleSchemaAllocator.h
+++ b/Code/Framework/AzCore/AzCore/Memory/SimpleSchemaAllocator.h
@@ -12,9 +12,7 @@
 #include <AzCore/std/typetraits/aligned_storage.h>
 #include <AzCore/std/typetraits/alignment_of.h>
 #include <AzCore/Memory/AllocatorBase.h>
-#include <AzCore/Debug/Profiler.h>
-
-#include <AzCore/Memory/AllocatorBase.h>
+#include <AzCore/Debug/MemoryProfiler.h>
 
 namespace AZ
 {
@@ -82,7 +80,7 @@ namespace AZ
 
             if (ProfileAllocations)
             {
-                AZ_PROFILE_MEMORY_ALLOC_EX(AZ::Debug::ProfileCategory::MemoryReserved, fileName, lineNum, ptr, byteSize, name ? name : GetName());
+                AZ_PROFILE_MEMORY_ALLOC_EX(MemoryReserved, fileName, lineNum, ptr, byteSize, name ? name : GetName());
                 AZ_MEMORY_PROFILE(ProfileAllocation(ptr, byteSize, alignment, name, fileName, lineNum, suppressStackRecord));
             }
 
@@ -102,7 +100,7 @@ namespace AZ
 
             if (ProfileAllocations)
             {
-                AZ_PROFILE_MEMORY_FREE(AZ::Debug::ProfileCategory::MemoryReserved, ptr);
+                AZ_PROFILE_MEMORY_FREE(MemoryReserved, ptr);
                 AZ_MEMORY_PROFILE(ProfileDeallocation(ptr, byteSize, alignment, nullptr));
             }
 
@@ -128,7 +126,7 @@ namespace AZ
         {
             if (ProfileAllocations)
             {
-                AZ_PROFILE_MEMORY_FREE(AZ::Debug::ProfileCategory::MemoryReserved, ptr);
+                AZ_PROFILE_MEMORY_FREE(MemoryReserved, ptr);
             }
 
             newSize = MemorySizeAdjustedUp(newSize);
@@ -142,7 +140,7 @@ namespace AZ
 
             if (ProfileAllocations)
             {
-                AZ_PROFILE_MEMORY_ALLOC(AZ::Debug::ProfileCategory::MemoryReserved, newPtr, newSize, GetName());
+                AZ_PROFILE_MEMORY_ALLOC(MemoryReserved, newPtr, newSize, GetName());
                 AZ_MEMORY_PROFILE(ProfileReallocationEnd(ptr, newPtr, newSize, newAlignment));
             }
 
diff --git a/Code/Framework/AzCore/AzCore/Memory/SystemAllocator.cpp b/Code/Framework/AzCore/AzCore/Memory/SystemAllocator.cpp
index ada6c8f330..41c70b4e30 100644
--- a/Code/Framework/AzCore/AzCore/Memory/SystemAllocator.cpp
+++ b/Code/Framework/AzCore/AzCore/Memory/SystemAllocator.cpp
@@ -254,7 +254,7 @@ SystemAllocator::Allocate(size_type byteSize, size_type alignment, int flags, co
 
     AZ_Assert(address != 0, "SystemAllocator: Failed to allocate %d bytes aligned on %d (flags: 0x%08x) %s : %s (%d)!", byteSize, alignment, flags, name ? name : "(no name)", fileName ? fileName : "(no file name)", lineNum);
 
-    AZ_PROFILE_MEMORY_ALLOC_EX(AZ::Debug::ProfileCategory::MemoryReserved, fileName, lineNum, address, byteSize, name);
+    AZ_PROFILE_MEMORY_ALLOC_EX(MemoryReserved, fileName, lineNum, address, byteSize, name);
     AZ_MEMORY_PROFILE(ProfileAllocation(address, byteSize, alignment, name, fileName, lineNum, suppressStackRecord + 1));
 
     return address;
@@ -268,7 +268,7 @@ void
 SystemAllocator::DeAllocate(pointer_type ptr, size_type byteSize, size_type alignment)
 {
     byteSize = MemorySizeAdjustedUp(byteSize);
-    AZ_PROFILE_MEMORY_FREE(AZ::Debug::ProfileCategory::MemoryReserved, ptr);
+    AZ_PROFILE_MEMORY_FREE(MemoryReserved, ptr);
     AZ_MEMORY_PROFILE(ProfileDeallocation(ptr, byteSize, alignment, nullptr));
     m_allocator->DeAllocate(ptr, byteSize, alignment);
 }
@@ -283,9 +283,9 @@ SystemAllocator::ReAllocate(pointer_type ptr, size_type newSize, size_type newAl
     newSize = MemorySizeAdjustedUp(newSize);
 
     AZ_MEMORY_PROFILE(ProfileReallocationBegin(ptr, newSize));
-    AZ_PROFILE_MEMORY_FREE(AZ::Debug::ProfileCategory::MemoryReserved, ptr);
+    AZ_PROFILE_MEMORY_FREE(MemoryReserved, ptr);
     pointer_type newAddress = m_allocator->ReAllocate(ptr, newSize, newAlignment);
-    AZ_PROFILE_MEMORY_ALLOC(AZ::Debug::ProfileCategory::MemoryReserved, newAddress, newSize, "SystemAllocator realloc");
+    AZ_PROFILE_MEMORY_ALLOC(MemoryReserved, newAddress, newSize, "SystemAllocator realloc");
     AZ_MEMORY_PROFILE(ProfileReallocationEnd(ptr, newAddress, newSize, newAlignment));
 
     return newAddress;
diff --git a/Code/Framework/AzCore/AzCore/Script/ScriptSystemComponent.cpp b/Code/Framework/AzCore/AzCore/Script/ScriptSystemComponent.cpp
index fa61a225c8..018f9ed15a 100644
--- a/Code/Framework/AzCore/AzCore/Script/ScriptSystemComponent.cpp
+++ b/Code/Framework/AzCore/AzCore/Script/ScriptSystemComponent.cpp
@@ -291,7 +291,7 @@ void    ScriptSystemComponent::OnSystemTick()
         if (contextContainer.m_context->GetId() == ScriptContextIds::DefaultScriptContextId)
         {
             size_t memoryUsageBytes = contextContainer.m_context->GetMemoryUsage();
-            AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Script, memoryUsageBytes / 1024.0, "Script Memory (KB)");
+            AZ_PROFILE_DATAPOINT(Script, memoryUsageBytes / 1024.0, "Script Memory (KB)");
         }
 #endif // AZ_PROFILE_TELEMETRY
 
diff --git a/Code/Framework/AzCore/AzCore/Serialization/DataPatch.cpp b/Code/Framework/AzCore/AzCore/Serialization/DataPatch.cpp
index 12bb474cfe..edc0e8398b 100644
--- a/Code/Framework/AzCore/AzCore/Serialization/DataPatch.cpp
+++ b/Code/Framework/AzCore/AzCore/Serialization/DataPatch.cpp
@@ -143,7 +143,7 @@ namespace AZ
     //=========================================================================
     void DataNodeTree::Build(const void* rootClassPtr, const Uuid& rootClassId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         m_root.Reset();
         m_currentNode = nullptr;
@@ -1400,7 +1400,7 @@ namespace AZ
 
         AddressTypeElement AddressTypeSerializer::LoadAddressElementFromPath(const AZStd::string& pathElement) const
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             // AddressTypeElement default constructor defaults to an invalid addressElement
             AddressTypeElement addressElement;
@@ -1485,13 +1485,13 @@ namespace AZ
         /// Load the class data from a stream.
         bool AddressTypeSerializer::Load(void* classPtr, IO::GenericStream& stream, unsigned int version, bool isDataBigEndian /*= false*/)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
             (void)isDataBigEndian;
             constexpr unsigned int version1PathAddress = 1;
 
             if (version < version1PathAddress)
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "AddressTypeSerializer::Load::LegacyUpgrade");
+                AZ_PROFILE_SCOPE(AzCore, "AddressTypeSerializer::Load::LegacyUpgrade");
                 // Grab the AddressType object to be filled
                 AddressType* address = reinterpret_cast<AddressType*>(classPtr);
                 address->clear();
@@ -1516,7 +1516,7 @@ namespace AZ
             }
             else
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "AddressTypeSerializer::Load::CurrentFlow");
+                AZ_PROFILE_SCOPE(AzCore, "AddressTypeSerializer::Load::CurrentFlow");
                 // Grab the AddressType object to be filled
                 AddressType* address = reinterpret_cast<AddressType*>(classPtr);
                 address->clear();
@@ -1749,7 +1749,7 @@ namespace AZ
         const FlagsMap& targetFlagsMap,
         SerializeContext* context)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         if (!source || !target)
         {
@@ -1804,7 +1804,7 @@ namespace AZ
             targetTree.Build(target, targetClassId);
 
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "DataPatch::Create:RecursiveCallToCompareElements");
+                AZ_PROFILE_SCOPE(AzCore, "DataPatch::Create:RecursiveCallToCompareElements");
 
                 sourceTree.CompareElements(
                     &sourceTree.m_root,
@@ -1829,7 +1829,7 @@ namespace AZ
         const FlagsMap& sourceFlagsMap,
         const FlagsMap& targetFlagsMap) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         if (!source)
         {
@@ -1870,7 +1870,7 @@ namespace AZ
 
         {
             // Loop over the original data patch and make a copy of the key value pair
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "DataPatch::Apply:UpgradeDataPatch");
+            AZ_PROFILE_SCOPE(AzCore, "DataPatch::Apply:UpgradeDataPatch");
             // Copy of the patch element is purposefully being created here(notice no ampersand) so that the UpgradeDataPatch
             // function can modify the key and insert it into the fixed patch map
             for (PatchMap::value_type patch : m_patch)
@@ -1883,7 +1883,7 @@ namespace AZ
         // Build a mapping of child patches for quick look-up: [parent patch address] -> [list of patches for child elements (parentAddress + one more address element)]
             ChildPatchMap childPatchMap;
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "DataPatch::Apply:GenerateChildPatchMap");
+            AZ_PROFILE_SCOPE(AzCore, "DataPatch::Apply:GenerateChildPatchMap");
             for (auto& patch : fixedPatch)
             {
                 AddressType parentAddress = patch.first;
@@ -1921,7 +1921,7 @@ namespace AZ
             }
         }
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "DataPatch::Apply:RecursiveCallToApplyToElements");
+            AZ_PROFILE_SCOPE(AzCore, "DataPatch::Apply:RecursiveCallToApplyToElements");
             int rootContainerElementCounter = 0;
 
             result = DataNodeTree::ApplyToElements(
@@ -2015,7 +2015,7 @@ namespace AZ
     */
     bool LegacyDataPatchConverter(AZ::SerializeContext& context, AZ::SerializeContext::DataElementNode& classElement)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
         AZ::Outcome<void, AZStd::string> conversionResult = LegacyDataPatchConverter_Impl(context, classElement);
 
         if (!conversionResult.IsSuccess())
@@ -2043,7 +2043,7 @@ namespace AZ
     */
     AZ::Outcome<void, AZStd::string> LegacyDataPatchConverter_Impl(AZ::SerializeContext& context, AZ::SerializeContext::DataElementNode& classElement)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
         // Pull the targetClassId value out of the class element before it gets cleared when converting the DataPatch TypeId
         AZ::TypeId targetClassTypeId;
         if (!classElement.GetChildData(AZ_CRC("m_targetClassId", 0xcabab9dc), targetClassTypeId))
diff --git a/Code/Framework/AzCore/AzCore/Serialization/ObjectStream.cpp b/Code/Framework/AzCore/AzCore/Serialization/ObjectStream.cpp
index e0ee18633b..73ab174699 100644
--- a/Code/Framework/AzCore/AzCore/Serialization/ObjectStream.cpp
+++ b/Code/Framework/AzCore/AzCore/Serialization/ObjectStream.cpp
@@ -786,7 +786,7 @@ namespace AZ
                 // Serializable leaf element.
                 else if (classData->m_serializer)
                 {
-                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "ObjectStreamImpl::LoadClass Load");
+                    AZ_PROFILE_SCOPE(AzCore, "ObjectStreamImpl::LoadClass Load");
 
                     // Wrap the stream
                     IO::GenericStream* currentStream = &m_inStream;
@@ -1929,7 +1929,7 @@ namespace AZ
         //=========================================================================
         bool ObjectStreamImpl::Start()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             ++m_pending;
 
diff --git a/Code/Framework/AzCore/AzCore/Serialization/SerializationUtils.cpp b/Code/Framework/AzCore/AzCore/Serialization/SerializationUtils.cpp
index fdc7cd94b6..c8e6c28679 100644
--- a/Code/Framework/AzCore/AzCore/Serialization/SerializationUtils.cpp
+++ b/Code/Framework/AzCore/AzCore/Serialization/SerializationUtils.cpp
@@ -24,7 +24,7 @@ namespace AZ
     {
         bool LoadObjectFromStreamInPlace(IO::GenericStream& stream, AZ::SerializeContext* context, const SerializeContext::ClassData* objectClassData, void* targetPointer, const FilterDescriptor& filterDesc)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             AZ_Assert(objectClassData, "Class data is required.");
 
@@ -72,7 +72,7 @@ namespace AZ
 
         bool LoadObjectFromStreamInPlace(IO::GenericStream& stream, AZ::SerializeContext* context, const Uuid& targetClassId, void* targetPointer, const FilterDescriptor& filterDesc)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             if (!context)
             {
@@ -111,7 +111,7 @@ namespace AZ
 
         void* LoadObjectFromStream(IO::GenericStream& stream, AZ::SerializeContext* context, const Uuid* targetClassId, const FilterDescriptor& filterDesc)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             if (!context)
             {
@@ -169,7 +169,7 @@ namespace AZ
 
         void* LoadObjectFromFile(const AZStd::string& filePath, const Uuid& targetClassId, SerializeContext* context, const FilterDescriptor& filterDesc, int /*platformFlags*/)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             AZ::IO::FileIOStream fileStream;           
             if (!fileStream.Open(filePath.c_str(), IO::OpenMode::ModeRead | IO::OpenMode::ModeBinary))
@@ -183,7 +183,7 @@ namespace AZ
 
         bool SaveObjectToStream(IO::GenericStream& stream, DataStream::StreamType streamType, const void* classPtr, const Uuid& classId, SerializeContext* context, const SerializeContext::ClassData* classData)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             if (!context)
             {
@@ -243,7 +243,7 @@ namespace AZ
 
         bool SaveObjectToFile(const AZStd::string& filePath, DataStream::StreamType fileType, const void* classPtr, const Uuid& classId, SerializeContext* context, int platformFlags)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             // \note This is ok for tools, but we should use the streamer to write objects directly (no memory store)
             AZStd::vector<AZ::u8> dstData;
diff --git a/Code/Framework/AzCore/AzCore/Slice/SliceComponent.cpp b/Code/Framework/AzCore/AzCore/Slice/SliceComponent.cpp
index 4cfccfa8bb..23a197b2ad 100644
--- a/Code/Framework/AzCore/AzCore/Slice/SliceComponent.cpp
+++ b/Code/Framework/AzCore/AzCore/Slice/SliceComponent.cpp
@@ -198,7 +198,7 @@ namespace AZ
         const EntityIdToEntityIdMap* remapFromIdToId/*=nullptr*/,
         const DataFlagsTransformFunction& dataFlagsTransformFn/*=nullptr*/)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         for (const auto& entityIdFlagsMapPair : from.m_entityToDataFlags)
         {
@@ -240,7 +240,7 @@ namespace AZ
     //=========================================================================
     DataPatch::FlagsMap SliceComponent::DataFlagsPerEntity::GetDataFlagsForPatching(const EntityIdToEntityIdMap* remapFromIdToId /*=nullptr*/) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         // Collect together data flags from all entities
         DataPatch::FlagsMap dataFlagsForAllEntities;
@@ -423,7 +423,7 @@ namespace AZ
     //=========================================================================
     void SliceComponent::DataFlagsPerEntity::Cleanup(const EntityList& validEntities)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         EntityIdSet validEntityIds;
         for (const Entity* entity : validEntities)
@@ -677,7 +677,7 @@ namespace AZ
     //=========================================================================
     SliceComponent::SliceInstance* SliceComponent::SliceReference::PrepareCreateInstance(const SliceInstanceId& sliceInstanceId, bool allowUninstantiated)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         // create an empty instance (just copy of the existing data)
         SliceInstance* instance = CreateEmptyInstance(sliceInstanceId);
@@ -737,7 +737,7 @@ namespace AZ
         AZ::SerializeContext* serializeContext,
         const AZ::IdUtils::Remapper<AZ::EntityId>::IdMapper& customMapper)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         if (!remapContainer)
         {
@@ -808,7 +808,7 @@ namespace AZ
     SliceComponent::SliceInstance* SliceComponent::SliceReference::CreateInstance(const AZ::IdUtils::Remapper<AZ::EntityId>::IdMapper& customMapper, 
         SliceInstanceId sliceInstanceId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         // Validate that we are able to create an instance at this time
         // If we are instantiated then this includes verifying that we have a valid component and asset
@@ -842,7 +842,7 @@ namespace AZ
         const EntityIdToEntityIdMap assetToLiveIdMap,
         SliceInstanceId sliceInstanceId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         // Validate that we are able to create an instance at this time
         // This includes verifying that we are instantiated, and have a valid component and asset
@@ -883,7 +883,7 @@ namespace AZ
     SliceComponent::SliceInstance* SliceComponent::SliceReference::CloneInstance(SliceComponent::SliceInstance* instance, 
                                                                                  SliceComponent::EntityIdToEntityIdMap& sourceToCloneEntityIdMap)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         // check if source instance belongs to this slice reference
         auto findIt = AZStd::find_if(m_instances.begin(), m_instances.end(), [instance](const SliceInstance& element) -> bool { return &element == instance; });
@@ -1053,7 +1053,7 @@ namespace AZ
     //=========================================================================
     bool SliceComponent::SliceReference::Instantiate(const AZ::ObjectStream::FilterDescriptor& filterDesc)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         if (m_isInstantiated)
         {
@@ -1145,7 +1145,7 @@ namespace AZ
     //=========================================================================
     void SliceComponent::SliceReference::InstantiateInstance(SliceInstance& instance, const AZ::ObjectStream::FilterDescriptor& filterDesc)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         // Could have set this during SliceInstance() constructor, but we wait until instantiation since it involves allocation.
         instance.m_dataFlags.SetIsValidEntityFunction([&instance](EntityId entityId) { return instance.IsValidEntity(entityId); });
@@ -1167,7 +1167,7 @@ namespace AZ
         // An empty map indicates its a fresh instance (i.e. has never be instantiated and then serialized).
         if (entityIdMap.empty())
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "SliceComponent::SliceReference::InstantiateInstance:FreshInstanceClone");
+            AZ_PROFILE_SCOPE(AzCore, "SliceComponent::SliceReference::InstantiateInstance:FreshInstanceClone");
 
             // Generate new Ids and populate the map.
             AZ_Assert(!dataPatch.IsValid(), "Data patch is valid for slice instance, but entity Id map is not!");
@@ -1175,7 +1175,7 @@ namespace AZ
         }
         else
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "SliceComponent::SliceReference::InstantiateInstance:CloneAndApplyDataPatches");
+            AZ_PROFILE_SCOPE(AzCore, "SliceComponent::SliceReference::InstantiateInstance:CloneAndApplyDataPatches");
 
             // Clone entities while applying any data patches.
             AZ_Assert(dataPatch.IsValid(), "Data patch is not valid for existing slice instance!");
@@ -1261,7 +1261,7 @@ namespace AZ
         // Broadcast OnSliceEntitiesLoaded for freshly instantiated entities.
         if (!instance.m_instantiated->m_entities.empty())
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "SliceComponent::SliceReference::InstantiateInstance:OnSliceEntitiesLoaded");
+            AZ_PROFILE_SCOPE(AzCore, "SliceComponent::SliceReference::InstantiateInstance:OnSliceEntitiesLoaded");
             SliceAssetSerializationNotificationBus::Broadcast(&SliceAssetSerializationNotificationBus::Events::OnSliceEntitiesLoaded, instance.m_instantiated->m_entities);
         }
     }
@@ -1363,7 +1363,7 @@ namespace AZ
     //=========================================================================
     void SliceComponent::SliceReference::ComputeDataPatch()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         // Get source entities from the base asset (instantiate if needed)
         InstantiatedContainer source(m_asset.Get()->GetComponent(), false);
@@ -1499,7 +1499,7 @@ namespace AZ
     //=========================================================================
     bool SliceComponent::GetEntities(EntityList& entities)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         bool result = true;
 
@@ -1532,7 +1532,7 @@ namespace AZ
     //=========================================================================
     bool SliceComponent::GetEntityIds(EntityIdSet& entities)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         bool result = true;
 
@@ -1582,7 +1582,7 @@ namespace AZ
     //=========================================================================
     bool SliceComponent::GetMetadataEntityIds(EntityIdSet& metadataEntities)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         bool result = true;
 
@@ -1654,7 +1654,7 @@ namespace AZ
     //=========================================================================
     SliceComponent::InstantiateResult SliceComponent::Instantiate()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
         AZStd::unique_lock<AZStd::recursive_mutex> lock(m_instantiateMutex);
 
         if (m_slicesAreInstantiated)
@@ -1856,7 +1856,7 @@ namespace AZ
     SliceComponent::SliceInstanceAddress SliceComponent::AddSliceUsingExistingEntities(const Data::Asset<SliceAsset>& sliceAsset, const AZ::SliceComponent::EntityIdToEntityIdMap& liveToAssetMap,
         SliceInstanceId sliceInstanceId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         if (!sliceAsset.Get()->GetComponent())
         {
@@ -2337,7 +2337,7 @@ namespace AZ
     //=========================================================================
     bool SliceComponent::RemoveSliceInstance(SliceComponent::SliceInstanceAddress sliceAddress)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
         if (!sliceAddress.IsValid())
         {
             AZ_Error("Slices", false, "Slice address is invalid.");
@@ -2474,7 +2474,7 @@ namespace AZ
 
     bool SliceComponent::RemoveMetaDataEntity(EntityId metaDataEntityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         GetEntityInfoMap(); // Ensure map is built
 
@@ -2567,7 +2567,7 @@ namespace AZ
 
     void SliceComponent::RemoveAllEntities(bool deleteEntities, bool removeEmptyInstances)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         // If we are deleting the entities, we need to do that one by one
         if (deleteEntities)
@@ -2930,7 +2930,7 @@ namespace AZ
     //=========================================================================
     void SliceComponent::OnAssetReloaded(Data::Asset<Data::AssetData> /*asset*/)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         if (!m_myAsset)
         {
@@ -3073,7 +3073,7 @@ namespace AZ
         /// Called right after we finish writing data to the instance pointed at by classPtr.
         void OnWriteEnd(void* classPtr) override
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             SliceComponent* sliceComponent = reinterpret_cast<SliceComponent*>(classPtr);
             EBUS_EVENT(SliceAssetSerializationNotificationBus, OnWriteDataToSliceAssetEnd, *sliceComponent);
@@ -3082,7 +3082,7 @@ namespace AZ
             // We can't broadcast this event for instanced entities yet, since they don't exist until instantiation.
             if (!sliceComponent->GetNewEntities().empty())
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "SliceComponentSerializationEvents::OnWriteEnd:OnSliceEntitiesLoaded");
+                AZ_PROFILE_SCOPE(AzCore, "SliceComponentSerializationEvents::OnWriteEnd:OnSliceEntitiesLoaded");
                 EBUS_EVENT(SliceAssetSerializationNotificationBus, OnSliceEntitiesLoaded, sliceComponent->GetNewEntities());
             }
         }
@@ -3093,7 +3093,7 @@ namespace AZ
     //=========================================================================
     void SliceComponent::PrepareSave()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         if (m_slicesAreInstantiated)
         {
@@ -3262,7 +3262,7 @@ namespace AZ
     //=========================================================================
     void SliceComponent::BuildEntityInfoMap()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         m_entityInfoMap.clear();
         m_metaDataEntityInfoMap.clear();
@@ -3425,7 +3425,7 @@ namespace AZ
     //=========================================================================
     void SliceComponent::BuildDataFlagsForInstances()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
         AZ_Assert(IsInstantiated(), "Slice must be instantiated before the ancestry of its data flags can be calculated.");
 
         // Use lock since slice instantiation can occur from multiple threads
@@ -3551,7 +3551,7 @@ namespace AZ
     {
         // if this function is a performance bottleneck, it could be optimized with caching
         // be wary not to create the cache in-game if the information is only needed by tools
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         if (!IsInstantiated())
         {
@@ -3730,7 +3730,7 @@ namespace AZ
     //=========================================================================
     SliceComponent* SliceComponent::Clone(AZ::SerializeContext& serializeContext, SliceInstanceToSliceInstanceMap* sourceToCloneSliceInstanceMap) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         SliceComponent* clonedComponent = serializeContext.CloneObject(this);
 
diff --git a/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxy.h b/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxy.h
index 7d55a88f19..4f58e0cb73 100644
--- a/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxy.h
+++ b/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxy.h
@@ -24,7 +24,7 @@
 #endif // #if defined(AZ_PROFILE_SCOPE)
 
 #define AZ_PROFILE_SCOPE(profiler, scopeNameId) \
-    static_assert(profiler < AZ::Debug::ProfileCategory::Count, "Invalid profiler category"); \
+    static_assert(profiler < Count, "Invalid profiler category"); \
     static const AZStd::string AZ_JOIN(blockName, __LINE__)(scopeNameId); \
     AZ::Statistics::StatisticalProfilerProxy::TimedScope AZ_JOIN(scope, __LINE__)(profiler, AZ_JOIN(blockName, __LINE__));
 
@@ -34,7 +34,7 @@ namespace AZ
 {
     namespace Statistics
     {
-        using StatisticalProfilerId = AZ::Debug::ProfileCategory;
+        using StatisticalProfilerId = AZ::Name;
 
         //! This AZ::Interface<> (Yes, it is an application wide singleton) owns an array of StatisticalProfilers.
         //! When is this useful?
@@ -124,8 +124,8 @@ namespace AZ
 
             StatisticalProfilerProxy()
             {
-                m_profilers.reserve(static_cast<AZStd::size_t>(AZ::Debug::ProfileCategory::Count));
-                for (AZStd::size_t i = 0; i < static_cast<AZStd::size_t>(AZ::Debug::ProfileCategory::Count); i++)
+                m_profilers.reserve(static_cast<AZStd::size_t>(Count));
+                for (AZStd::size_t i = 0; i < static_cast<AZStd::size_t>(Count); i++)
                 {
                     m_profilers.emplace_back(StatisticalProfilerType());
                 }
@@ -162,7 +162,7 @@ namespace AZ
             }
 
         private:
-            AZStd::bitset<static_cast<AZStd::size_t>(AZ::Debug::ProfileCategory::Count)> m_activeProfilersFlag;
+            AZStd::bitset<static_cast<AZStd::size_t>(Count)> m_activeProfilersFlag;
             AZStd::vector<StatisticalProfilerType> m_profilers;
         }; //class StatisticalProfilerProxy
 
diff --git a/Code/Framework/AzCore/AzCore/Statistics/TimeDataStatisticsManager.h b/Code/Framework/AzCore/AzCore/Statistics/TimeDataStatisticsManager.h
index c9adc4de2f..4b5c58f426 100644
--- a/Code/Framework/AzCore/AzCore/Statistics/TimeDataStatisticsManager.h
+++ b/Code/Framework/AzCore/AzCore/Statistics/TimeDataStatisticsManager.h
@@ -17,7 +17,7 @@ namespace AZ
         /**
          * @brief Specialization useful for data generated with AZ::Debug::FrameProfileComponent
          *
-         * Timer based data collection using AZ_PROFILE_TIMER(...), available in
+         * Timer based data collection using AZ_PROFILE_SCOPE(...), available in
          * AzCore/Debug/Profiler.h can be collected when using AZ::Debug::FrameProfilerComponent
          * and AZ::Debug::FrameProfilerBus. The method PushTimeDataSample(...) is a convenience
          * to convert those Timer registers into a RunningStatistic.
diff --git a/Code/Framework/AzCore/AzCore/azcore_files.cmake b/Code/Framework/AzCore/AzCore/azcore_files.cmake
index 0c95b9d592..79d3e321ec 100644
--- a/Code/Framework/AzCore/AzCore/azcore_files.cmake
+++ b/Code/Framework/AzCore/AzCore/azcore_files.cmake
@@ -99,6 +99,7 @@ set(FILES
     Debug/FrameProfilerComponent.cpp
     Debug/FrameProfilerComponent.h
     Debug/IEventLogger.h
+    Debug/MemoryProfiler.h
     Debug/ProfileModuleInit.cpp
     Debug/ProfileModuleInit.h
     Debug/Profiler.cpp
@@ -565,10 +566,6 @@ set(FILES
     Statistics/NamedRunningStatistic.h
     Statistics/RunningStatistic.cpp
     Statistics/RunningStatistic.h
-    Statistics/StatisticalProfiler.h
-    Statistics/StatisticalProfilerProxy.h
-    Statistics/StatisticalProfilerProxySystemComponent.cpp
-    Statistics/StatisticalProfilerProxySystemComponent.h
     Statistics/StatisticsManager.h
     Statistics/TimeDataStatisticsManager.cpp
     Statistics/TimeDataStatisticsManager.h
diff --git a/Code/Framework/AzCore/AzCore/std/parallel/spin_mutex.h b/Code/Framework/AzCore/AzCore/std/parallel/spin_mutex.h
index 926e404668..2fc4c331ee 100644
--- a/Code/Framework/AzCore/AzCore/std/parallel/spin_mutex.h
+++ b/Code/Framework/AzCore/AzCore/std/parallel/spin_mutex.h
@@ -8,7 +8,6 @@
 #ifndef AZSTD_PARALLEL_SPIN_MUTEX_H
 #define AZSTD_PARALLEL_SPIN_MUTEX_H 1
 
-#include <AzCore/Debug/Profiler.h>
 #include <AzCore/std/parallel/atomic.h>
 #include <AzCore/std/parallel/exponential_backoff.h>
 
@@ -32,8 +31,6 @@ namespace AZStd
             bool expected = false;
             if (!m_flag.compare_exchange_weak(expected, true, memory_order_acq_rel, memory_order_acquire))
             {
-                AZ_PROFILE_FUNCTION_STALL(AZ::Debug::ProfileCategory::AzCore);
-
                 exponential_backoff backoff;
                 for (;; )
                 {
diff --git a/Code/Framework/AzCore/Platform/Common/RadTelemetry/ProfileTelemetry.h b/Code/Framework/AzCore/Platform/Common/RadTelemetry/ProfileTelemetry.h
index 3337df9ede..7677c985c6 100644
--- a/Code/Framework/AzCore/Platform/Common/RadTelemetry/ProfileTelemetry.h
+++ b/Code/Framework/AzCore/Platform/Common/RadTelemetry/ProfileTelemetry.h
@@ -35,21 +35,17 @@ namespace ProfileTelemetryInternal
     }
 }
 
-#define  AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category) (static_cast<AZ::Debug::ProfileCategoryPrimitiveType>(1) << static_cast<AZ::Debug::ProfileCategoryPrimitiveType>(category))
+#define  AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category) (static_cast<uint32_t>(1) << static_cast<uint32_t>(category))
 // Helpers
-#define AZ_INTERNAL_PROF_VERIFY_CAT(category) static_assert(category < AZ::Debug::ProfileCategory::Count, "Invalid profile category")
-
 #define AZ_INTERNAL_PROF_MEMORY_CAT_TO_FLAGS(category) (AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category) | \
         AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(AZ::Debug::ProfileCategory::MemoryReserved))
 
 #define AZ_INTERNAL_PROF_VERIFY_INTERVAL_ID(id) static_assert(sizeof(id) <= sizeof(tm_uint64), "Interval id must be a unique value no larger than 64-bits")
 
 #define AZ_INTERNAL_PROF_TM_FUNC_VERIFY_CAT(category, flags) \
-    AZ_INTERNAL_PROF_VERIFY_CAT(category); \
     tmFunction(AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category), flags)
 
 #define AZ_INTERNAL_PROF_TM_ZONE_VERIFY_CAT(category, flags, ...) \
-    AZ_INTERNAL_PROF_VERIFY_CAT(category); \
     tmZone(AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category), flags, __VA_ARGS__)    
 
 // AZ_PROFILE_FUNCTION
@@ -91,28 +87,23 @@ namespace ProfileTelemetryInternal
 // For profiling events that do not start and stop in the same scope (they MUST start/stop on the same thread)
 // ALWAYS favor using scoped events (AZ_PROFILE_FUNCTION, AZ_PROFILE_SCOPE) as debugging an unmatched begin/end can be challenging
 #define AZ_PROFILE_EVENT_BEGIN(category, name) \
-    AZ_INTERNAL_PROF_VERIFY_CAT(category); \
     tmEnter(AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category), TMZF_NONE, name)
 
 #define AZ_PROFILE_EVENT_END(category) \
-    AZ_INTERNAL_PROF_VERIFY_CAT(category); \
     tmLeave(AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category))
 
 
 // AZ_PROFILE_INTERVAL (mapped to Telemetry Timespan APIs)
 // Note: using C-style casting as we allow either pointers or integral types as IDs
 #define AZ_PROFILE_INTERVAL_START(category, id, ...) \
-    AZ_INTERNAL_PROF_VERIFY_CAT(category); \
     AZ_INTERNAL_PROF_VERIFY_INTERVAL_ID(id); \
     tmBeginTimeSpan(AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category), (tm_uint64)(id), TMZF_NONE, __VA_ARGS__)
 
 #define AZ_PROFILE_INTERVAL_START_COLORED(category, id, color, ...) \
-    AZ_INTERNAL_PROF_VERIFY_CAT(category); \
     AZ_INTERNAL_PROF_VERIFY_INTERVAL_ID(id); \
     tmBeginColoredTimeSpan(AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category), (tm_uint64)(id), 0, ProfileTelemetryInternal::ConvertColor(color), TMZF_NONE, __VA_ARGS__)
 
 #define AZ_PROFILE_INTERVAL_END(category, id) \
-    AZ_INTERNAL_PROF_VERIFY_CAT(category); \
     AZ_INTERNAL_PROF_VERIFY_INTERVAL_ID(id); \
     tmEndTimeSpan(AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category), (tm_uint64)(id))
 
@@ -122,7 +113,6 @@ namespace ProfileTelemetryInternal
 // Note: the first variable argument must be a const format string
 // Usage: AZ_PROFILE_INTERVAL_SCOPED(AZ::Debug::ProfileCategory, <unique interval id>, <printf style const format string>, format args...)
 #define AZ_PROFILE_INTERVAL_SCOPED(category, id,  ...) \
-    AZ_INTERNAL_PROF_VERIFY_CAT(category); \
     AZ_INTERNAL_PROF_VERIFY_INTERVAL_ID(id); \
     tmTimeSpan(AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category), (tm_uint64)(id), TM_MIN_TIME_SPAN_TRACK_ID + static_cast<AZ::Debug::ProfileCategoryPrimitiveType>(category), 0, TMZF_NONE, __VA_ARGS__)
 
@@ -131,29 +121,23 @@ namespace ProfileTelemetryInternal
 // Note: data points can have static or dynamic names, if using a dynamic name the first variable argument must be a const format string
 // Usage: AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory, <printf style const format string>, format args...)
 #define AZ_PROFILE_DATAPOINT(category, value, ...) \
-    AZ_INTERNAL_PROF_VERIFY_CAT(category); \
     tmPlot(AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category), TM_PLOT_UNITS_REAL, TM_PLOT_DRAW_LINE, static_cast<double>(value), __VA_ARGS__)
 
 #define AZ_PROFILE_DATAPOINT_PERCENT(category, value, ...) \
-    AZ_INTERNAL_PROF_VERIFY_CAT(category); \
     tmPlot(AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category), TM_PLOT_UNITS_PERCENTAGE_DIRECT, TM_PLOT_DRAW_LINE, static_cast<double>(value), __VA_ARGS__)
 
 
 // AZ_PROFILE_MEMORY_ALLOC
 #define AZ_PROFILE_MEMORY_ALLOC(category, address, size, context) \
-    AZ_INTERNAL_PROF_VERIFY_CAT(category); \
     tmAlloc(AZ_INTERNAL_PROF_MEMORY_CAT_TO_FLAGS(category), address, size, context)
 
 #define AZ_PROFILE_MEMORY_ALLOC_EX(category, filename, lineNumber, address, size, context) \
-    AZ_INTERNAL_PROF_VERIFY_CAT(category); \
     tmAllocEx(AZ_INTERNAL_PROF_MEMORY_CAT_TO_FLAGS(category), filename, lineNumber, address, size, context)
 
 #define AZ_PROFILE_MEMORY_FREE(category, address) \
-    AZ_INTERNAL_PROF_VERIFY_CAT(category); \
     tmFree(AZ_INTERNAL_PROF_MEMORY_CAT_TO_FLAGS(category), address)
 
 #define AZ_PROFILE_MEMORY_FREE_EX(category, filename, lineNumber, address) \
-    AZ_INTERNAL_PROF_VERIFY_CAT(category); \
     tmFreeEx(AZ_INTERNAL_PROF_MEMORY_CAT_TO_FLAGS(category), filename, lineNumber, address)
 
 #endif
diff --git a/Code/Framework/AzCore/Platform/Common/UnixLike/AzCore/IO/SystemFile_UnixLike.cpp b/Code/Framework/AzCore/Platform/Common/UnixLike/AzCore/IO/SystemFile_UnixLike.cpp
index 797f3e35e8..8f651a9559 100644
--- a/Code/Framework/AzCore/Platform/Common/UnixLike/AzCore/IO/SystemFile_UnixLike.cpp
+++ b/Code/Framework/AzCore/Platform/Common/UnixLike/AzCore/IO/SystemFile_UnixLike.cpp
@@ -10,6 +10,7 @@
 #include <AzCore/IO/FileIO.h>
 #include <AzCore/IO/FileIOEventBus.h>
 #include <AzCore/Casting/numeric_cast.h>
+#include <AzCore/Debug/Profiler.h>
 
 #include <AzCore/PlatformIncl.h>
 #include <AzCore/Utils/Utils.h>
@@ -208,7 +209,7 @@ namespace Platform
 
     bool DeleteDir(const char* dirName)
     {
-        AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::DeleteDir(util) - %s", dirName);
+        AZ_PROFILE_SCOPE(AzCore, "SystemFile::DeleteDir(util) - %s", dirName);
 
         if (dirName)
         {
diff --git a/Code/Framework/AzCore/Platform/Windows/AzCore/IO/Streamer/StorageDrive_Windows.cpp b/Code/Framework/AzCore/Platform/Windows/AzCore/IO/Streamer/StorageDrive_Windows.cpp
index 2489749b51..2462af861b 100644
--- a/Code/Framework/AzCore/Platform/Windows/AzCore/IO/Streamer/StorageDrive_Windows.cpp
+++ b/Code/Framework/AzCore/Platform/Windows/AzCore/IO/Streamer/StorageDrive_Windows.cpp
@@ -169,7 +169,7 @@ namespace AZ::IO
 
     void StorageDriveWin::PrepareRequest(FileRequest* request)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
         AZ_Assert(request, "PrepareRequest was provided a null request.");
 
         if (AZStd::holds_alternative<FileRequest::ReadRequestData>(request->GetCommand()))
@@ -189,7 +189,7 @@ namespace AZ::IO
 
     void StorageDriveWin::QueueRequest(FileRequest* request)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
         AZ_Assert(request, "QueueRequest was provided a null request.");
 
         AZStd::visit([this, request](auto&& args)
@@ -459,7 +459,7 @@ namespace AZ::IO
 
             // Adding explicit scope here for profiling file Open & Close
             {
-                AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "StorageDriveWin::ReadRequest OpenFile %s", m_name.c_str());
+                AZ_PROFILE_SCOPE(AzCore, "StorageDriveWin::ReadRequest OpenFile %s", m_name.c_str());
                 TIMED_AVERAGE_WINDOW_SCOPE(m_fileOpenCloseTimeAverage);
 
                 // All reads are overlapped (asynchronous).
@@ -516,7 +516,7 @@ namespace AZ::IO
 
     bool StorageDriveWin::ReadRequest(FileRequest* request)
     {
-        AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "StorageDriveWin::ReadRequest %s", m_name.c_str());
+        AZ_PROFILE_SCOPE(AzCore, "StorageDriveWin::ReadRequest %s", m_name.c_str());
 
         if (!m_cachesInitialized)
         {
@@ -545,7 +545,7 @@ namespace AZ::IO
 
     bool StorageDriveWin::ReadRequest(FileRequest* request, size_t readSlot)
     {
-        AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "StorageDriveWin::ReadRequest %s", m_name.c_str());
+        AZ_PROFILE_SCOPE(AzCore, "StorageDriveWin::ReadRequest %s", m_name.c_str());
 
         if (!m_context->GetStreamerThreadSynchronizer().AreEventHandlesAvailable())
         {
@@ -666,7 +666,7 @@ namespace AZ::IO
 
         bool result = false;
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "StorageDriveWin::ReadRequest ::ReadFile");
+            AZ_PROFILE_SCOPE(AzCore, "StorageDriveWin::ReadRequest ::ReadFile");
             result = ::ReadFile(file, output, readSize, nullptr, overlapped);
         }
 
@@ -782,7 +782,7 @@ namespace AZ::IO
     {
         auto& fileExists = AZStd::get<FileRequest::FileExistsCheckData>(request->GetCommand());
 
-        AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "StorageDriveWin::FileExistsRequest %s : %s",
+        AZ_PROFILE_SCOPE(AzCore, "StorageDriveWin::FileExistsRequest %s : %s",
             m_name.c_str(), fileExists.m_path.GetRelativePath());
         TIMED_AVERAGE_WINDOW_SCOPE(m_getFileExistsTimeAverage);
 
@@ -838,7 +838,7 @@ namespace AZ::IO
     {
         auto& command = AZStd::get<FileRequest::FileMetaDataRetrievalData>(request->GetCommand());
 
-        AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "StorageDriveWin::FileMetaDataRetrievalRequest %s : %s",
+        AZ_PROFILE_SCOPE(AzCore, "StorageDriveWin::FileMetaDataRetrievalRequest %s : %s",
             m_name.c_str(), command.m_path.GetRelativePath());
         TIMED_AVERAGE_WINDOW_SCOPE(m_getFileMetaDataRetrievalTimeAverage);
 
@@ -954,7 +954,7 @@ namespace AZ::IO
 
     bool StorageDriveWin::FinalizeReads()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         bool hasWorked = false;
         for (size_t readSlot = 0; readSlot < m_readSlots_active.size(); ++readSlot)
diff --git a/Code/Framework/AzCore/Tests/Components.cpp b/Code/Framework/AzCore/Tests/Components.cpp
index b14dcbbe53..45193f4d1e 100644
--- a/Code/Framework/AzCore/Tests/Components.cpp
+++ b/Code/Framework/AzCore/Tests/Components.cpp
@@ -1244,19 +1244,18 @@ namespace UnitTest
 
         int ChildFunction(int input)
         {
-            AZ_PROFILE_TIMER("UnitTest", nullptr, NamedRegister);
+            AZ_PROFILE_FUNCTION(System);
             int result = 5;
             for (int i = 0; i < 10000; ++i)
             {
                 result += i % (input + 3);
             }
-            AZ_PROFILE_TIMER_END(NamedRegister);
             return result;
         }
 
         int ChildFunction1(int input)
         {
-            AZ_PROFILE_TIMER("UnitTest", "Child1");
+            AZ_PROFILE_SCOPE(System, "Child1");
             int result = 5;
             for (int i = 0; i < 10000; ++i)
             {
@@ -1267,7 +1266,7 @@ namespace UnitTest
 
         int Profile1(int numIterations)
         {
-            AZ_PROFILE_TIMER("UnitTest", "Custom name");
+            AZ_PROFILE_SCOPE(System, "Custom name");
             int result = 0;
             for (int i = 0; i < numIterations; ++i)
             {
diff --git a/Code/Framework/AzCore/Tests/Debug.cpp b/Code/Framework/AzCore/Tests/Debug.cpp
index 6181823737..0d6e1a51e0 100644
--- a/Code/Framework/AzCore/Tests/Debug.cpp
+++ b/Code/Framework/AzCore/Tests/Debug.cpp
@@ -171,276 +171,6 @@ namespace UnitTest
         run();
     }
 
-    class ProfilerTest
-        : public AllocatorsFixture
-    {
-    public:
-        int m_numRegistersReceived;
-
-        bool ReadRegisterCallback(const ProfilerRegister& reg, const AZStd::thread_id& id)
-        {
-            (void)reg;
-            (void)id;
-            switch (reg.m_type)
-            {
-            case ProfilerRegister::PRT_TIME:
-            {
-                AZ_TEST_ASSERT(reg.m_timeData.m_time > 0);
-                AZ_TEST_ASSERT(reg.m_timeData.m_calls > 0);
-            } break;
-            case ProfilerRegister::PRT_VALUE:
-            {
-                AZ_TEST_ASSERT(reg.m_userValues.m_value1 == 1 || reg.m_userValues.m_value1 == 2);
-                AZ_TEST_ASSERT(reg.m_userValues.m_value2 == 0 || reg.m_userValues.m_value2 == 2 || reg.m_userValues.m_value2 == 4);
-                AZ_TEST_ASSERT(reg.m_userValues.m_value3 == 0 || reg.m_userValues.m_value3 == 3 || reg.m_userValues.m_value3 == 6);
-                AZ_TEST_ASSERT(reg.m_userValues.m_value4 == 0 || reg.m_userValues.m_value4 == 4 || reg.m_userValues.m_value4 == 8);
-                AZ_TEST_ASSERT(reg.m_userValues.m_value5 == 0 || reg.m_userValues.m_value5 == 5 || reg.m_userValues.m_value5 == 10);
-            } break;
-            }
-
-            //AZ::u64 threadId = (AZ::u64)id.m_id;
-            //AZ_TracePrintf("Profiler","[%llu] '%s' '%s'(%d) %d Ms (Child calls: %d time: %d Ms) Parent: '%s'!\n",threadId,
-            //  reg.m_name,reg.m_function,reg.m_line,reg.m_time.count(),reg.m_childrenCalls,reg.m_childrenTime.count(),reg.m_lastParent ? reg.m_lastParent->m_name : "No");
-            ++m_numRegistersReceived;
-            return true;
-        }
-
-        int ChildFunction(int input)
-        {
-            AZ_PROFILE_TIMER("UnitTest");
-
-            auto start = AZStd::chrono::system_clock::now();
-
-            int result = 5;
-            for (int i = 0; i < 30000; ++i)
-            {
-                result += i % (input + 3);
-            }
-
-            auto end = AZStd::chrono::system_clock::now();
-            AZ_TEST_ASSERT(end >= start);
-            while (end <= start)
-            {
-                end = AZStd::chrono::system_clock::now();
-            }
-            return result;
-        }
-
-        int ChildFunction1(int input)
-        {
-            AZ_PROFILE_TIMER("UnitTest", "Child1");
-
-            auto start = AZStd::chrono::system_clock::now();
-
-            int result = 5;
-            for (int i = 0; i < 30000; ++i)
-            {
-                result += i % (input + 1);
-            }
-
-
-            auto end = AZStd::chrono::system_clock::now();
-            AZ_TEST_ASSERT(end >= start);
-            while (end <= start)
-            {
-                end = AZStd::chrono::system_clock::now();
-            }
-
-            return result;
-        }
-
-        int Profile1(int numIterations)
-        {
-            AZ_PROFILE_TIMER("UnitTest", "Custom name");
-            int result = 0;
-            for (int i = 0; i < numIterations; ++i)
-            {
-                result += ChildFunction(i);
-            }
-
-            result += ChildFunction1(numIterations / 3);
-            return result;
-        }
-
-        void UserValuesSet()
-        {
-            AZ_PROFILE_VALUE_SET("UnitTest", "UserValues1", 1);
-            AZ_PROFILE_VALUE_SET("UnitTest", "UserValues2", 1, 2);
-            AZ_PROFILE_VALUE_SET("UnitTest", "UserValues3", 1, 2, 3);
-            AZ::s64 v1 = 1, v2 = 2, v3 = 3, v4 = 4, v5 = 5;
-            AZ_PROFILE_VALUE_SET("UnitTest", "UserValues4", v1, v2, v3, v4);
-            AZ_PROFILE_VALUE_SET("UnitTest", "UserValues5", v1, v2, v3, v4, v5);
-
-            // test named register
-            AZ_PROFILE_VALUE_SET_NAMED("UnitTest", "UserValues5", userValues5, v1, v2, v3, v4, v5);
-#if defined(AZ_PROFILER_MACRO_DISABLE)
-            (void)v1;
-            (void)v2;
-            (void)v3;
-            (void)v4;
-            (void)v5;
-#else
-            AZ_TEST_ASSERT(userValues5 != nullptr);
-#endif // !defined(AZ_PROFILER_MACRO_DISABLE)
-        }
-
-        void UserValuesAdd(int numAdditions)
-        {
-            for (int i = 0; i < numAdditions; ++i)
-            {
-                AZ_PROFILE_VALUE_ADD("UnitTest", "UserValues1", 1);
-                AZ_PROFILE_VALUE_ADD("UnitTest", "UserValues2", 1, 2);
-                AZ_PROFILE_VALUE_ADD("UnitTest", "UserValues3", 1, 2, 3);
-                AZ::s64 v1 = 1, v2 = 2, v3 = 3, v4 = 4, v5 = 5;
-                AZ_PROFILE_VALUE_ADD("UnitTest", "UserValues4", v1, v2, v3, v4);
-                AZ_PROFILE_VALUE_ADD("UnitTest", "UserValues5", v1, v2, v3, v4, v5);
-
-                // test named register
-                AZ_PROFILE_VALUE_ADD_NAMED("UnitTest", "UserValues5", userValues5, v1, v2, v3, v4, v5);
-#if defined(AZ_PROFILER_MACRO_DISABLE)
-                (void)v1;
-                (void)v2;
-                (void)v3;
-                (void)v4;
-                (void)v5;
-#else
-                AZ_TEST_ASSERT(userValues5 != nullptr);
-#endif // !defined(AZ_PROFILER_MACRO_DISABLE)
-            }
-        }
-
-        void run()
-        {
-            AZ_TEST_ASSERT(!Profiler::IsReady());
-            Profiler::Create();
-            AZ_TEST_ASSERT(Profiler::IsReady());
-            Profiler::Destroy();
-            AZ_TEST_ASSERT(!Profiler::IsReady());
-
-#if !defined(AZ_PROFILER_MACRO_DISABLE)
-            Profiler::Create();
-
-            //Profile1();
-
-            //Profiler::Instance().ReadRegisterValues(AZStd::bind(&ProfilerTest::ReadRegisterCallback,this,AZStd::placeholders::_1,AZStd::placeholders::_2));
-
-            //Profiler::Instance().ResetRegisters();
-
-            AZStd::thread_id removeThreadId;
-            AZStd::chrono::microseconds elapsed[2];
-            int numIterations = 10000;
-            for (int i = 0; i < 2; ++i)
-            {
-                // for the second run we should not record any data
-                if (i == 1)
-                {
-                    Profiler::Instance().DeactivateSystem("UnitTest");
-                }
-
-                AZStd::chrono::system_clock::time_point start = AZStd::chrono::system_clock::now();
-                AZStd::thread t1(AZStd::bind(&ProfilerTest::Profile1, this, numIterations));
-                AZStd::thread t2(AZStd::bind(&ProfilerTest::Profile1, this, numIterations));
-                AZStd::thread t3(AZStd::bind(&ProfilerTest::Profile1, this, numIterations));
-                AZStd::thread t4(AZStd::bind(&ProfilerTest::Profile1, this, numIterations));
-                AZStd::thread t5(AZStd::bind(&ProfilerTest::Profile1, this, numIterations));
-                AZStd::thread t6(AZStd::bind(&ProfilerTest::Profile1, this, numIterations));
-                AZStd::thread t7(AZStd::bind(&ProfilerTest::Profile1, this, numIterations));
-                AZStd::thread t8(AZStd::bind(&ProfilerTest::Profile1, this, numIterations));
-
-                removeThreadId = t4.get_id();
-
-                t1.join();
-                t2.join();
-                t3.join();
-                t4.join();
-                t5.join();
-                t6.join();
-                t7.join();
-                t8.join();
-                elapsed[i] = AZStd::chrono::system_clock::now() - start;
-                //AZ_Printf("Profiler","Elapsed time %d\n",elapsed[i].count());
-
-                if (i == 0)
-                {
-                    // just as test remove all associated data and registers.
-                    Profiler::Instance().RemoveThreadData(removeThreadId);
-                }
-
-                m_numRegistersReceived = 0;
-                Profiler::Instance().ReadRegisterValues(AZStd::bind(&ProfilerTest::ReadRegisterCallback, this, AZStd::placeholders::_1, AZStd::placeholders::_2));
-                if (i == 0)
-                {
-                    AZ_TEST_ASSERT(m_numRegistersReceived == 7 * 3); // 3 registers for each thread (8 threads - 1 we removed the data for 't4')
-                }
-                else
-                {
-                    AZ_TEST_ASSERT(m_numRegistersReceived == 0);
-                }
-            }
-            Profiler::Destroy();
-
-            // Test user value registers
-            Profiler::Create();
-
-            for (int i = 0; i < 2; ++i)
-            {
-                // for the second run we should not record any data
-                if (i == 1)
-                {
-                    Profiler::Instance().DeactivateSystem("UnitTest");
-                }
-
-                AZStd::thread t1(AZStd::bind(&ProfilerTest::UserValuesSet, this));
-                AZStd::thread t2(AZStd::bind(&ProfilerTest::UserValuesSet, this));
-                AZStd::thread t3(AZStd::bind(&ProfilerTest::UserValuesSet, this));
-                AZStd::thread t4(AZStd::bind(&ProfilerTest::UserValuesSet, this));
-                AZStd::thread t5(AZStd::bind(&ProfilerTest::UserValuesAdd, this, 2));
-                AZStd::thread t6(AZStd::bind(&ProfilerTest::UserValuesAdd, this, 2));
-                AZStd::thread t7(AZStd::bind(&ProfilerTest::UserValuesAdd, this, 2));
-                AZStd::thread t8(AZStd::bind(&ProfilerTest::UserValuesAdd, this, 2));
-
-                removeThreadId = t4.get_id();
-
-                t1.join();
-                t2.join();
-                t3.join();
-                t4.join();
-                t5.join();
-                t6.join();
-                t7.join();
-                t8.join();
-
-                if (i == 0)
-                {
-                    // just as test remove all associated data and registers.
-                    Profiler::Instance().RemoveThreadData(removeThreadId);
-                }
-
-                m_numRegistersReceived = 0;
-                Profiler::Instance().ReadRegisterValues(AZStd::bind(&ProfilerTest::ReadRegisterCallback, this, AZStd::placeholders::_1, AZStd::placeholders::_2));
-                if (i == 0)
-                {
-                    AZ_TEST_ASSERT(m_numRegistersReceived == 7 * 6); // 6 registers for each thread (8 threads - 1 we removed the data for 't4' )
-                }
-                else
-                {
-                    AZ_TEST_ASSERT(m_numRegistersReceived == 0);
-                }
-            }
-            Profiler::Destroy();
-#endif
-        }
-    };
-#if AZ_TRAIT_DISABLE_FAILED_PROFILER_TEST
-    TEST_F(ProfilerTest, DISABLED_Test)
-#else
-    TEST_F(ProfilerTest, Test)
-#endif // AZ_TRAIT_DISABLE_FAILED_PROFILER_TEST
-
-    {
-        run();
-    }
-
     TEST(Time, Test)
     {
         AZStd::sys_time_t ticksPerSecond = AZStd::GetTimeTicksPerSecond();
diff --git a/Code/Framework/AzCore/Tests/StatisticalProfiler.cpp b/Code/Framework/AzCore/Tests/StatisticalProfiler.cpp
index 04e70d92a5..6d6023b872 100644
--- a/Code/Framework/AzCore/Tests/StatisticalProfiler.cpp
+++ b/Code/Framework/AzCore/Tests/StatisticalProfiler.cpp
@@ -317,7 +317,7 @@ namespace UnitTest
         AZ::Statistics::StatisticalProfilerProxy::TimedScope::ClearCachedProxy();
         AZ::Statistics::StatisticalProfilerProxy profilerProxy;
         AZ::Statistics::StatisticalProfilerProxy* proxy = AZ::Interface<AZ::Statistics::StatisticalProfilerProxy>::Get();
-        AZ::Statistics::StatisticalProfilerProxy::StatisticalProfilerType& profiler = proxy->GetProfiler(AZ::Debug::ProfileCategory::Terrain);
+        AZ::Statistics::StatisticalProfilerProxy::StatisticalProfilerType& profiler = proxy->GetProfiler(Terrain);
 
         const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdPerformance = "PerformanceResult";
         const AZStd::string statNamePerformance("PerformanceResult");
@@ -328,15 +328,15 @@ namespace UnitTest
         ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdPerformance, statNamePerformance, "us") != nullptr);
         ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdBlock, statNameBlock, "us") != nullptr);
 
-        proxy->ActivateProfiler(AZ::Debug::ProfileCategory::Terrain, true);
+        proxy->ActivateProfiler(Terrain, true);
 
         const int iter_count = 10;
         {
-            CODE_PROFILER_PROXY_PUSH_TIME(AZ::Debug::ProfileCategory::Terrain, statIdPerformance)
+            CODE_PROFILER_PROXY_PUSH_TIME(Terrain, statIdPerformance)
             int counter = 0;
             for (int i = 0; i < iter_count; i++)
             {
-                CODE_PROFILER_PROXY_PUSH_TIME(AZ::Debug::ProfileCategory::Terrain, statIdBlock)
+                CODE_PROFILER_PROXY_PUSH_TIME(Terrain, statIdBlock)
                     counter++;
             }
         }
@@ -348,7 +348,7 @@ namespace UnitTest
         EXPECT_EQ(profiler.GetStatistic(statIdBlock)->GetNumSamples(), iter_count);
 
         //Clean Up
-        proxy->ActivateProfiler(AZ::Debug::ProfileCategory::Terrain, false);
+        proxy->ActivateProfiler(Terrain, false);
 
 #undef CODE_PROFILER_PROXY_PUSH_TIME
 
@@ -362,12 +362,12 @@ namespace UnitTest
         const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread1("simple_thread1");
         const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread1_loop("simple_thread1_loop");
 
-        CODE_PROFILER_PROXY_PUSH_TIME(AZ::Debug::ProfileCategory::Terrain, simple_thread1);
+        CODE_PROFILER_PROXY_PUSH_TIME(Terrain, simple_thread1);
 
         static int counter = 0;
         for (int i = 0; i < loop_cnt; i++)
         {
-            CODE_PROFILER_PROXY_PUSH_TIME(AZ::Debug::ProfileCategory::Terrain, simple_thread1_loop);
+            CODE_PROFILER_PROXY_PUSH_TIME(Terrain, simple_thread1_loop);
             counter++;
         }
     }
@@ -377,12 +377,12 @@ namespace UnitTest
         const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread2("simple_thread2");
         const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread2_loop("simple_thread2_loop");
 
-        CODE_PROFILER_PROXY_PUSH_TIME(AZ::Debug::ProfileCategory::Terrain, simple_thread2);
+        CODE_PROFILER_PROXY_PUSH_TIME(Terrain, simple_thread2);
 
         static int counter = 0;
         for (int i = 0; i < loop_cnt; i++)
         {
-            CODE_PROFILER_PROXY_PUSH_TIME(AZ::Debug::ProfileCategory::Terrain, simple_thread2_loop);
+            CODE_PROFILER_PROXY_PUSH_TIME(Terrain, simple_thread2_loop);
             counter++;
         }
     }
@@ -392,12 +392,12 @@ namespace UnitTest
         const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread3("simple_thread3");
         const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread3_loop("simple_thread3_loop");
 
-        CODE_PROFILER_PROXY_PUSH_TIME(AZ::Debug::ProfileCategory::Terrain, simple_thread3);
+        CODE_PROFILER_PROXY_PUSH_TIME(Terrain, simple_thread3);
 
         static int counter = 0;
         for (int i = 0; i < loop_cnt; i++)
         {
-            CODE_PROFILER_PROXY_PUSH_TIME(AZ::Debug::ProfileCategory::Terrain, simple_thread3_loop);
+            CODE_PROFILER_PROXY_PUSH_TIME(Terrain, simple_thread3_loop);
         }
     }
 
@@ -408,7 +408,7 @@ namespace UnitTest
         AZ::Statistics::StatisticalProfilerProxy::TimedScope::ClearCachedProxy();
         AZ::Statistics::StatisticalProfilerProxy profilerProxy;
         AZ::Statistics::StatisticalProfilerProxy* proxy = AZ::Interface<AZ::Statistics::StatisticalProfilerProxy>::Get();
-        AZ::Statistics::StatisticalProfilerProxy::StatisticalProfilerType& profiler = proxy->GetProfiler(AZ::Debug::ProfileCategory::Terrain);
+        AZ::Statistics::StatisticalProfilerProxy::StatisticalProfilerType& profiler = proxy->GetProfiler(Terrain);
 
         const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread1 = "simple_thread1";
         const AZStd::string statNameThread1("simple_thread1");
@@ -432,7 +432,7 @@ namespace UnitTest
         ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3, statNameThread3, "us"));
         ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3Loop, statNameThread3Loop, "us"));
 
-        proxy->ActivateProfiler(AZ::Debug::ProfileCategory::Terrain, true);
+        proxy->ActivateProfiler(Terrain, true);
 
         //Let's kickoff the threads to see how much contention affects the profiler's performance.
         const int iter_count = 10;
@@ -459,7 +459,7 @@ namespace UnitTest
         EXPECT_EQ(profiler.GetStatistic(statIdThread3Loop)->GetNumSamples(), iter_count);
 
         //Clean Up
-        proxy->ActivateProfiler(AZ::Debug::ProfileCategory::Terrain, false);
+        proxy->ActivateProfiler(Terrain, false);
     }
 
     /** Trace message handler to track messages during tests
@@ -745,7 +745,7 @@ namespace UnitTest
         AZ::Statistics::StatisticalProfilerProxy::TimedScope::ClearCachedProxy();
         AZ::Statistics::StatisticalProfilerProxy profilerProxy;
         AZ::Statistics::StatisticalProfilerProxy* proxy = AZ::Interface<AZ::Statistics::StatisticalProfilerProxy>::Get();
-        AZ::Statistics::StatisticalProfilerProxy::StatisticalProfilerType& profiler = proxy->GetProfiler(AZ::Debug::ProfileCategory::Terrain);
+        AZ::Statistics::StatisticalProfilerProxy::StatisticalProfilerType& profiler = proxy->GetProfiler(Terrain);
 
         const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdPerformance = "PerformanceResult";
         const AZStd::string statNamePerformance("PerformanceResult");
@@ -756,15 +756,15 @@ namespace UnitTest
         ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdPerformance, statNamePerformance, "us") != nullptr);
         ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdBlock, statNameBlock, "us") != nullptr);
 
-        proxy->ActivateProfiler(AZ::Debug::ProfileCategory::Terrain, true);
+        proxy->ActivateProfiler(Terrain, true);
 
         const int iter_count = 1000000;
         {
-            CODE_PROFILER_PROXY_PUSH_TIME(AZ::Debug::ProfileCategory::Terrain, statIdPerformance)
+            CODE_PROFILER_PROXY_PUSH_TIME(Terrain, statIdPerformance)
                 int counter = 0;
             for (int i = 0; i < iter_count; i++)
             {
-                CODE_PROFILER_PROXY_PUSH_TIME(AZ::Debug::ProfileCategory::Terrain, statIdBlock)
+                CODE_PROFILER_PROXY_PUSH_TIME(Terrain, statIdBlock)
                     counter++;
             }
         }
@@ -778,7 +778,7 @@ namespace UnitTest
         profiler.LogAndResetStats("StatisticalProfilerProxy");
 
         //Clean Up
-        proxy->ActivateProfiler(AZ::Debug::ProfileCategory::Terrain, false);
+        proxy->ActivateProfiler(Terrain, false);
     }
 
 #undef CODE_PROFILER_PROXY_PUSH_TIME
@@ -788,7 +788,7 @@ namespace UnitTest
         AZ::Statistics::StatisticalProfilerProxy::TimedScope::ClearCachedProxy();
         AZ::Statistics::StatisticalProfilerProxy profilerProxy;
         AZ::Statistics::StatisticalProfilerProxy* proxy = AZ::Interface<AZ::Statistics::StatisticalProfilerProxy>::Get();
-        AZ::Statistics::StatisticalProfilerProxy::StatisticalProfilerType& profiler = proxy->GetProfiler(AZ::Debug::ProfileCategory::Terrain);
+        AZ::Statistics::StatisticalProfilerProxy::StatisticalProfilerType& profiler = proxy->GetProfiler(Terrain);
 
         const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread1 = "simple_thread1";
         const AZStd::string statNameThread1("simple_thread1");
@@ -812,7 +812,7 @@ namespace UnitTest
         ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3, statNameThread3, "us"));
         ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3Loop, statNameThread3Loop, "us"));
 
-        proxy->ActivateProfiler(AZ::Debug::ProfileCategory::Terrain, true);
+        proxy->ActivateProfiler(Terrain, true);
 
         //Let's kickoff the threads to see how much contention affects the profiler's performance.
         const int iter_count = 1000000;
@@ -841,7 +841,7 @@ namespace UnitTest
         profiler.LogAndResetStats("3_Threads_StatisticalProfilerProxy");
 
         //Clean Up
-        proxy->ActivateProfiler(AZ::Debug::ProfileCategory::Terrain, false);
+        proxy->ActivateProfiler(Terrain, false);
     }
 
 }//namespace UnitTest
diff --git a/Code/Framework/AzCore/Tests/TimeDataStatistics.cpp b/Code/Framework/AzCore/Tests/TimeDataStatistics.cpp
index 50856b1df8..192d9dc7f6 100644
--- a/Code/Framework/AzCore/Tests/TimeDataStatistics.cpp
+++ b/Code/Framework/AzCore/Tests/TimeDataStatistics.cpp
@@ -83,7 +83,7 @@ namespace UnitTest
 
         int ChildFunction0(int numIterations, int sleepTimeMilliseconds)
         {
-            AZ_PROFILE_TIMER("UnitTest", CHILD_TIMER_STAT0);
+            AZ_PROFILE_SCOPE(AzCore, CHILD_TIMER_STAT0);
             AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(sleepTimeMilliseconds));
             int result = 5;
             for (int i = 0; i < numIterations; ++i)
@@ -95,7 +95,7 @@ namespace UnitTest
 
         int ChildFunction1(int numIterations, int sleepTimeMilliseconds)
         {
-            AZ_PROFILE_TIMER("UnitTest", CHILD_TIMER_STAT1);
+            AZ_PROFILE_SCOPE(AzCore, CHILD_TIMER_STAT1);
             AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(sleepTimeMilliseconds));
             int result = 5;
             for (int i = 0; i < numIterations; ++i)
@@ -107,7 +107,7 @@ namespace UnitTest
 
         int ParentFunction(int numIterations, int sleepTimeMilliseconds)
         {
-            AZ_PROFILE_TIMER("UnitTest", PARENT_TIMER_STAT);
+            AZ_PROFILE_SCOPE(AzCore, PARENT_TIMER_STAT);
             AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(sleepTimeMilliseconds));
             int result = 0;
             result += ChildFunction0(numIterations, sleepTimeMilliseconds);
diff --git a/Code/Framework/AzCore/Tests/azcoretests_files.cmake b/Code/Framework/AzCore/Tests/azcoretests_files.cmake
index ca0e2862fc..911eaa7b10 100644
--- a/Code/Framework/AzCore/Tests/azcoretests_files.cmake
+++ b/Code/Framework/AzCore/Tests/azcoretests_files.cmake
@@ -60,7 +60,6 @@ set(FILES
     SerializeContextFixture.h
     Slice.cpp
     State.cpp
-    StatisticalProfiler.cpp
     Statistics.cpp
     StreamerTests.cpp
     StringFunc.cpp
diff --git a/Code/Framework/AzFramework/AzFramework/Application/Application.cpp b/Code/Framework/AzFramework/AzFramework/Application/Application.cpp
index 7b4c328af9..abd97aee0d 100644
--- a/Code/Framework/AzFramework/AzFramework/Application/Application.cpp
+++ b/Code/Framework/AzFramework/AzFramework/Application/Application.cpp
@@ -11,6 +11,7 @@
 #include <AzCore/Math/Crc.h>
 #include <AzCore/Component/ComponentApplication.h>
 #include <AzCore/Component/NonUniformScaleBus.h>
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/Memory/MemoryComponent.h>
 #include <AzCore/Slice/SliceSystemComponent.h>
 #include <AzCore/Jobs/JobManagerComponent.h>
@@ -540,7 +541,7 @@ namespace AzFramework
         const AZStd::function<void()>& workForNewThread,
         const char* newThreadName)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzFramework);
+        AZ_PROFILE_FUNCTION(AzFramework);
 
         AZStd::thread_desc newThreadDesc;
         newThreadDesc.m_cpuId = AFFINITY_MASK_USERTHREADS;
@@ -548,7 +549,7 @@ namespace AzFramework
         AZStd::binary_semaphore binarySemaphore;
         AZStd::thread newThread([&workForNewThread, &binarySemaphore, &newThreadName]
         {
-            AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzFramework,
+            AZ_PROFILE_SCOPE(AzFramework,
                 "Application::PumpSystemEventLoopWhileDoingWorkInNewThread:ThreadWorker %s", newThreadName);
 
             workForNewThread();
@@ -559,7 +560,7 @@ namespace AzFramework
             PumpSystemEventLoopUntilEmpty();
         }
         {
-            AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzFramework,
+            AZ_PROFILE_SCOPE(AzFramework,
                 "Application::PumpSystemEventLoopWhileDoingWorkInNewThread:WaitOnThread %s", newThreadName);
             newThread.join();
         }
@@ -571,10 +572,14 @@ namespace AzFramework
     ////////////////////////////////////////////////////////////////////////////
     void Application::RunMainLoop()
     {
+        uint32_t frameCounter = 0;
         while (!m_exitMainLoopRequested)
         {
             PumpSystemEventLoopUntilEmpty();
+
+            AZ_PROFILE_SCOPE(AzCore, "Frame %i", frameCounter);
             Tick();
+            ++frameCounter;
         }
     }
 
diff --git a/Code/Framework/AzFramework/AzFramework/Archive/Archive.cpp b/Code/Framework/AzFramework/AzFramework/Archive/Archive.cpp
index a3d2103650..d263ad3d0b 100644
--- a/Code/Framework/AzFramework/AzFramework/Archive/Archive.cpp
+++ b/Code/Framework/AzFramework/AzFramework/Archive/Archive.cpp
@@ -13,6 +13,7 @@
 #include <AzCore/Casting/numeric_cast.h>
 #include <AzCore/Component/ComponentApplicationBus.h>
 #include <AzCore/Console/IConsole.h>
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/Interface/Interface.h>
 #include <AzCore/IO/SystemFile.h>
 #include <AzCore/IO/FileIO.h>
@@ -206,7 +207,7 @@ namespace AZ::IO::ArchiveInternal
     //////////////////////////////////////////////////////////////////////////
     size_t ArchiveInternal::CZipPseudoFile::FRead(void* pDest, size_t nSize, size_t nCount, [[maybe_unused]] AZ::IO::HandleType fileHandle)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         if (!GetFile())
         {
@@ -271,7 +272,7 @@ namespace AZ::IO::ArchiveInternal
     //////////////////////////////////////////////////////////////////////////
     void* ArchiveInternal::CZipPseudoFile::GetFileData(size_t& nFileSize, [[maybe_unused]] AZ::IO::HandleType fileHandle)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         if (!GetFile())
         {
@@ -685,7 +686,7 @@ namespace AZ::IO
     //////////////////////////////////////////////////////////////////////////
     AZ::IO::HandleType Archive::FOpen(AZStd::string_view pName, const char* szMode, uint32_t nInputFlags)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         const size_t pathLen = pName.size();
         if (pathLen == 0 || pathLen >= MaxPath)
@@ -693,7 +694,7 @@ namespace AZ::IO
             return AZ::IO::InvalidHandle;
         }
 
-        AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::Game, "File: %.*s Archive: %p",
+        AZ_PROFILE_SCOPE(Game, "File: %.*s Archive: %p",
             aznumeric_cast<int>(pName.size()), pName.data(), this);
 
         SAutoCollectFileAccessTime accessTime(this);
@@ -716,7 +717,7 @@ namespace AZ::IO
         }
 
         const bool fileWritable = (nOSFlags & (AZ::IO::OpenMode::ModeWrite | AZ::IO::OpenMode::ModeAppend | AZ::IO::OpenMode::ModeUpdate)) != AZ::IO::OpenMode::Invalid;
-        AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::Game, "File: %s Archive: %p", szFullPath->c_str(), this);
+        AZ_PROFILE_SCOPE(Game, "File: %s Archive: %p", szFullPath->c_str(), this);
         if (fileWritable)
         {
             // we need to open the file for writing, but we failed to do so.
@@ -1094,8 +1095,8 @@ namespace AZ::IO
     //////////////////////////////////////////////////////////////////////////
     size_t Archive::FReadRaw(void* pData, size_t nSize, size_t nCount, AZ::IO::HandleType fileHandle)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
-        AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::Game, "Size: %d Archive: %p", nSize, this);
+        AZ_PROFILE_FUNCTION(AzCore);
+        AZ_PROFILE_SCOPE(Game, "Size: %d Archive: %p", nSize, this);
         SAutoCollectFileAccessTime accessTime(this);
 
         ArchiveInternal::CZipPseudoFile* pseudoFile = GetPseudoFile(fileHandle);
@@ -1112,7 +1113,7 @@ namespace AZ::IO
     //////////////////////////////////////////////////////////////////////////
     size_t Archive::FReadRawAll(void* pData, size_t nFileSize, AZ::IO::HandleType fileHandle)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         SAutoCollectFileAccessTime accessTime(this);
         ArchiveInternal::CZipPseudoFile* pseudoFile = GetPseudoFile(fileHandle);
@@ -1130,7 +1131,7 @@ namespace AZ::IO
     //////////////////////////////////////////////////////////////////////////
     void* Archive::FGetCachedFileData(AZ::IO::HandleType fileHandle, size_t& nFileSize)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         SAutoCollectFileAccessTime accessTime(this);
         ArchiveInternal::CZipPseudoFile* pseudoFile = GetPseudoFile(fileHandle);
diff --git a/Code/Framework/AzFramework/AzFramework/Entity/EntityContext.cpp b/Code/Framework/AzFramework/AzFramework/Entity/EntityContext.cpp
index a323033001..c1283c9379 100644
--- a/Code/Framework/AzFramework/AzFramework/Entity/EntityContext.cpp
+++ b/Code/Framework/AzFramework/AzFramework/Entity/EntityContext.cpp
@@ -167,7 +167,7 @@ namespace AzFramework
     //=========================================================================
     void EntityContext::HandleEntitiesAdded(const EntityList& entities)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzFramework);
+        AZ_PROFILE_FUNCTION(AzFramework);
 
         for (AZ::Entity* entity : entities)
         {
@@ -184,7 +184,7 @@ namespace AzFramework
     //=========================================================================
     void EntityContext::HandleEntitiesRemoved(const EntityIdList& entityIds)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzFramework);
+        AZ_PROFILE_FUNCTION(AzFramework);
 
         for (AZ::EntityId id : entityIds)
         {
diff --git a/Code/Framework/AzFramework/AzFramework/Entity/SliceEntityOwnershipService.cpp b/Code/Framework/AzFramework/AzFramework/Entity/SliceEntityOwnershipService.cpp
index 8ed89ee121..9a077cd611 100644
--- a/Code/Framework/AzFramework/AzFramework/Entity/SliceEntityOwnershipService.cpp
+++ b/Code/Framework/AzFramework/AzFramework/Entity/SliceEntityOwnershipService.cpp
@@ -155,7 +155,7 @@ namespace AzFramework
 
     void SliceEntityOwnershipService::CreateRootSlice()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzFramework);
+        AZ_PROFILE_FUNCTION(AzFramework);
 
         AZ_Assert(m_rootAsset && m_rootAsset.Get(), "Root slice asset has not been created yet.");
 
@@ -164,7 +164,7 @@ namespace AzFramework
 
     void SliceEntityOwnershipService::CreateRootSlice(AZ::SliceAsset* rootSliceAsset)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzFramework);
+        AZ_PROFILE_FUNCTION(AzFramework);
         AZ_Assert(m_rootAsset && m_rootAsset.Get(), "Root slice asset has not been created yet.");
 
         AZ::Entity* rootEntity = new AZ::Entity();
@@ -240,7 +240,7 @@ namespace AzFramework
 
     bool SliceEntityOwnershipService::LoadFromStream(AZ::IO::GenericStream& stream, bool remapIds, EntityIdToEntityIdMap* idRemapTable, const AZ::ObjectStream::FilterDescriptor& filterDesc)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzFramework);
+        AZ_PROFILE_FUNCTION(AzFramework);
 
         AZ_Assert(m_rootAsset, "The entity ownership service has not been initialized.");
 
@@ -259,7 +259,7 @@ namespace AzFramework
     bool SliceEntityOwnershipService::HandleRootEntityReloadedFromStream(AZ::Entity* rootEntity, bool remapIds,
         AZ::SliceComponent::EntityIdToEntityIdMap* idRemapTable)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzFramework);
+        AZ_PROFILE_FUNCTION(AzFramework);
 
         if (!rootEntity)
         {
@@ -385,7 +385,7 @@ namespace AzFramework
 
     void SliceEntityOwnershipService::OnAssetReady(AZ::Data::Asset<AZ::Data::AssetData> readyAsset)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzFramework);
+        AZ_PROFILE_FUNCTION(AzFramework);
         AZ_ASSET_ATTACH_TO_SCOPE(readyAsset.Get());
 
         AZ_Assert(readyAsset.GetAs<AZ::SliceAsset>(), "Asset is not a slice!");
@@ -472,7 +472,7 @@ namespace AzFramework
 
     void SliceEntityOwnershipService::OnAssetReloaded(AZ::Data::Asset<AZ::Data::AssetData> asset)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzFramework);
+        AZ_PROFILE_FUNCTION(AzFramework);
         if (asset == m_rootAsset && asset.Get() != m_rootAsset.Get())
         {
             Reset();
@@ -548,7 +548,7 @@ namespace AzFramework
     AZ::SliceComponent::SliceInstanceAddress SliceEntityOwnershipService::CloneSliceInstance(
         AZ::SliceComponent::SliceInstanceAddress sourceInstance, AZ::SliceComponent::EntityIdToEntityIdMap& sourceToCloneEntityIdMap)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzFramework);
+        AZ_PROFILE_FUNCTION(AzFramework);
 
         AZ_Assert(sourceInstance.IsValid(), "Source slice instance is invalid.");
 
diff --git a/Code/Framework/AzFramework/AzFramework/IO/RemoteStorageDrive.cpp b/Code/Framework/AzFramework/AzFramework/IO/RemoteStorageDrive.cpp
index 5b38a5e966..8db0c27475 100644
--- a/Code/Framework/AzFramework/AzFramework/IO/RemoteStorageDrive.cpp
+++ b/Code/Framework/AzFramework/AzFramework/IO/RemoteStorageDrive.cpp
@@ -80,7 +80,7 @@ namespace AzFramework
     {
         using namespace AZ::IO;
 
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
         AZ_Assert(request, "PrepareRequest was provided a null request.");
 
         if (AZStd::holds_alternative<FileRequest::ReadRequestData>(request->GetCommand()))
@@ -278,7 +278,7 @@ namespace AzFramework
     {
         using namespace AZ::IO;
 
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
             
         auto data = AZStd::get_if<FileRequest::ReadData>(&request->GetCommand());
         AZ_Assert(data, "Request doing reading in the RemoteStorageDrive didn't contain read data.")
@@ -424,7 +424,7 @@ namespace AzFramework
     {
         using namespace AZ::IO;
 
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
         TIMED_AVERAGE_WINDOW_SCOPE(m_getFileMetaDataTimeAverage);
 
         AZ::u64 fileSize = 0;
diff --git a/Code/Framework/AzFramework/AzFramework/Script/ScriptComponent.cpp b/Code/Framework/AzFramework/AzFramework/Script/ScriptComponent.cpp
index 6b25c49b88..aaf2de3e58 100644
--- a/Code/Framework/AzFramework/AzFramework/Script/ScriptComponent.cpp
+++ b/Code/Framework/AzFramework/AzFramework/Script/ScriptComponent.cpp
@@ -619,7 +619,7 @@ namespace AzFramework
     //=========================================================================
     void ScriptComponent::LoadScript()
     {
-        AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::Script, "Load: %s", m_script.GetHint().c_str());
+        AZ_PROFILE_SCOPE(Script, "Load: %s", m_script.GetHint().c_str());
 
         // Load the script, find the base table, create the entity table
         // find the Activate/Deactivate functions in the script and call them
@@ -634,7 +634,7 @@ namespace AzFramework
     //=========================================================================
     void ScriptComponent::UnloadScript()
     {
-        AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::Script, "Unload: %s", m_script.GetHint().c_str());
+        AZ_PROFILE_SCOPE(Script, "Unload: %s", m_script.GetHint().c_str());
 
         DestroyEntityTable();
     }
@@ -822,7 +822,7 @@ namespace AzFramework
         lua_rawget(lua, baseStackIndex); // ScriptTable[OnActivate]
         if (lua_isfunction(lua, -1))
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Script, "OnActivate");
+            AZ_PROFILE_SCOPE(Script, "OnActivate");
             lua_rawgeti(lua, LUA_REGISTRYINDEX, m_table); // push the entity table as the only argument
             AZ::Internal::LuaSafeCall(lua, 1, 0); // Call OnActivate
         }
@@ -856,7 +856,7 @@ namespace AzFramework
             lua_rawget(lua, -2); // ScriptTable[OnDeactivte]
             if (lua_isfunction(lua, -1))
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Script, "OnDeactivate");
+                AZ_PROFILE_SCOPE(Script, "OnDeactivate");
 
                 lua_pushvalue(lua, -3); // push the entity table as the only argument
                 AZ::Internal::LuaSafeCall(lua, 1, 0); // Call OnDeactivate
diff --git a/Code/Framework/AzFramework/AzFramework/TargetManagement/TargetManagementComponent.cpp b/Code/Framework/AzFramework/AzFramework/TargetManagement/TargetManagementComponent.cpp
index eec384a695..c1ce31613c 100644
--- a/Code/Framework/AzFramework/AzFramework/TargetManagement/TargetManagementComponent.cpp
+++ b/Code/Framework/AzFramework/AzFramework/TargetManagement/TargetManagementComponent.cpp
@@ -625,7 +625,7 @@ namespace AzFramework
             return;
         }
 
-        AZ_PROFILE_TIMER("TargetManager");
+        AZ_PROFILE_SCOPE(AzFramework, "TargetManager::SendTmMessage");
         AZStd::vector<char, AZ::OSStdAllocator> msgBuffer;
         AZ::IO::ByteContainerStream<AZStd::vector<char, AZ::OSStdAllocator> > outMsg(&msgBuffer);
 
@@ -651,7 +651,7 @@ namespace AzFramework
 
     void TargetManagementComponent::DispatchMessages(MsgSlotId id)
     {
-        AZ_PROFILE_TIMER("TargetManager");
+        AZ_PROFILE_SCOPE(AzFramework, "TargetManager::DispatchMessages");
         AZStd::lock_guard<AZStd::mutex> lock(m_inboxMutex);
         size_t maxMsgsToProcess = m_inbox.size();
         TmMsgQueue::iterator itMsg = m_inbox.begin();
@@ -684,7 +684,7 @@ namespace AzFramework
         {
             if (m_networkImpl->m_gridMate)
             {
-                AZ_PROFILE_TIMER("TargetManager");
+                AZ_PROFILE_SCOPE(AzFramework, "TargetManager::Tick");
                 if (!m_networkImpl->m_session && !m_networkImpl->m_gridSearch)
                 {
                     if (AZStd::chrono::system_clock::now() > m_reconnectionTime)
@@ -694,7 +694,7 @@ namespace AzFramework
                 }
 
                 {
-                    AZ_PROFILE_TIMER("TargetManager", "Tick Gridmate");
+                    AZ_PROFILE_SCOPE(AzFramework, "TargetManager::Tick Gridmate");
                     m_networkImpl->m_gridMate->Update();
                     if (m_networkImpl->m_session && m_networkImpl->m_session->GetReplicaMgr())
                     {
@@ -707,7 +707,7 @@ namespace AzFramework
 
                 if (m_networkImpl->m_session)
                 {
-                    AZ_PROFILE_TIMER("TargetManager", "Send/Receive TmMsgs");
+                    AZ_PROFILE_SCOPE(AzFramework, "TargetManager::Tick Send/Receive TmMsgs");
 
                     // Receive
                     for (unsigned int i = 0; i < m_networkImpl->m_session->GetNumberOfMembers(); ++i)
diff --git a/Code/Framework/AzFramework/AzFramework/Visibility/EntityVisibilityBoundsUnionSystem.cpp b/Code/Framework/AzFramework/AzFramework/Visibility/EntityVisibilityBoundsUnionSystem.cpp
index c5253a8c89..bfa9dfcf9e 100644
--- a/Code/Framework/AzFramework/AzFramework/Visibility/EntityVisibilityBoundsUnionSystem.cpp
+++ b/Code/Framework/AzFramework/AzFramework/Visibility/EntityVisibilityBoundsUnionSystem.cpp
@@ -8,6 +8,7 @@
 
 #include "EntityVisibilityBoundsUnionSystem.h"
 
+#include <AzCore/Debug/Profiler.h>
 #include <AzFramework/Visibility/BoundsBus.h>
 #include <cstring>
 
@@ -42,7 +43,7 @@ namespace AzFramework
 
     void EntityVisibilityBoundsUnionSystem::OnEntityActivated(AZ::Entity* entity)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzFramework);
+        AZ_PROFILE_FUNCTION(AzFramework);
 
         // ignore any entity that might activate which does not have a TransformComponent
         if (entity->GetTransform() == nullptr)
@@ -68,7 +69,7 @@ namespace AzFramework
 
     void EntityVisibilityBoundsUnionSystem::OnEntityDeactivated(AZ::Entity* entity)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzFramework);
+        AZ_PROFILE_FUNCTION(AzFramework);
 
         // ignore any entity that might deactivate which does not have a TransformComponent
         if (entity->GetTransform() == nullptr)
@@ -89,7 +90,7 @@ namespace AzFramework
 
     void EntityVisibilityBoundsUnionSystem::UpdateVisibilitySystem(AZ::Entity* entity, EntityVisibilityBoundsUnionInstance& instance)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzFramework);
+        AZ_PROFILE_FUNCTION(AzFramework);
 
         if (const auto& localEntityBoundsUnions = instance.m_localEntityBoundsUnion; localEntityBoundsUnions.IsValid())
         {
@@ -136,7 +137,7 @@ namespace AzFramework
 
     void EntityVisibilityBoundsUnionSystem::ProcessEntityBoundsUnionRequests()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzFramework);
+        AZ_PROFILE_FUNCTION(AzFramework);
 
         // iterate over all entities whose bounds changed and recalculate them
         for (const auto& entity : m_entityBoundsDirty)
@@ -155,7 +156,7 @@ namespace AzFramework
 
     void EntityVisibilityBoundsUnionSystem::OnTransformUpdated(AZ::Entity* entity)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzFramework);
+        AZ_PROFILE_FUNCTION(AzFramework);
 
         // update the world transform of the visibility bounds union
         if (auto instance_it = m_entityVisibilityBoundsUnionInstanceMapping.find(entity);
diff --git a/Code/Framework/AzFramework/AzFramework/Visibility/EntityVisibilityQuery.cpp b/Code/Framework/AzFramework/AzFramework/Visibility/EntityVisibilityQuery.cpp
index 2023cb969d..96d371fa12 100644
--- a/Code/Framework/AzFramework/AzFramework/Visibility/EntityVisibilityQuery.cpp
+++ b/Code/Framework/AzFramework/AzFramework/Visibility/EntityVisibilityQuery.cpp
@@ -34,7 +34,7 @@ namespace AzFramework
 {
     void EntityVisibilityQuery::UpdateVisibility(const AzFramework::CameraState& cameraState)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzFramework);
+        AZ_PROFILE_FUNCTION(AzFramework);
 
         auto* visSystem = AZ::Interface<AzFramework::IVisibilitySystem>::Get();
         if (!visSystem)
diff --git a/Code/Framework/AzTest/AzTest/Platform/Android/AzTest_Traits_Android.h b/Code/Framework/AzTest/AzTest/Platform/Android/AzTest_Traits_Android.h
index b210fb9b62..cfd04d2a8b 100644
--- a/Code/Framework/AzTest/AzTest/Platform/Android/AzTest_Traits_Android.h
+++ b/Code/Framework/AzTest/AzTest/Platform/Android/AzTest_Traits_Android.h
@@ -30,7 +30,6 @@
 #define AZ_TRAIT_DISABLE_FAILED_MULTIPLAYER_GRIDMATE_TESTS true
 #define AZ_TRAIT_DISABLE_FAILED_NETWORKING_TESTS true
 #define AZ_TRAIT_DISABLE_FAILED_PHYSICS_TESTS true
-#define AZ_TRAIT_DISABLE_FAILED_PROFILER_TEST true
 #define AZ_TRAIT_DISABLE_FAILED_SAVE_DATA_TESTS true
 #define AZ_TRAIT_DISABLE_FAILED_SERIALIZE_BASIC_TEST true
 #define AZ_TRAIT_DISABLE_FAILED_STREAMER_TESTS true
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Application/ToolsApplication.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Application/ToolsApplication.cpp
index 56ef749247..3e895465e5 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Application/ToolsApplication.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Application/ToolsApplication.cpp
@@ -95,7 +95,7 @@ namespace AzToolsFramework
         template<typename IdContainerType>
         void DeleteEntities(const IdContainerType& entityIds)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             if (entityIds.empty())
             {
@@ -141,7 +141,7 @@ namespace AzToolsFramework
                 }
 
                 {
-                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "Internal::DeleteEntities:UndoCaptureAndPurgeEntities");
+                    AZ_PROFILE_SCOPE(AzToolsFramework, "Internal::DeleteEntities:UndoCaptureAndPurgeEntities");
                     for (const auto& entityId : entityIds)
                     {
                         AZ::Entity* entity = NULL;
@@ -160,7 +160,7 @@ namespace AzToolsFramework
 
                 selCommand->SetParent(currentUndoBatch);
                 {
-                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "Internal::DeleteEntities:RunRedo");
+                    AZ_PROFILE_SCOPE(AzToolsFramework, "Internal::DeleteEntities:RunRedo");
                     selCommand->RunRedo();
                 }
             }
@@ -458,7 +458,7 @@ namespace AzToolsFramework
 
     bool ToolsApplication::RemoveEntity(AZ::Entity* entity)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         auto undoCacheInterface = AZ::Interface<UndoSystem::UndoCacheInterface>::Get();
         if (undoCacheInterface)
@@ -472,7 +472,7 @@ namespace AzToolsFramework
         EBUS_EVENT(ToolsApplicationEvents::Bus, EntityDeregistered, entity->GetId());
 
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "ToolsApplication::RemoveEntity:CallApplicationRemoveEntity");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "ToolsApplication::RemoveEntity:CallApplicationRemoveEntity");
             if (AzFramework::Application::RemoveEntity(entity))
             {
                 return true;
@@ -545,7 +545,7 @@ namespace AzToolsFramework
 
     void ToolsApplication::MarkEntitySelected(AZ::EntityId entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         AZ_Assert(entityId.IsValid(), "Invalid entity Id being marked as selected.");
 
         EntityIdList::iterator foundIter = AZStd::find(m_selectedEntities.begin(), m_selectedEntities.end(), entityId);
@@ -563,7 +563,7 @@ namespace AzToolsFramework
 
     void ToolsApplication::MarkEntitiesSelected(const EntityIdList& entitiesToSelect)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         EntityIdList entitiesSelected;
         entitiesSelected.reserve(entitiesToSelect.size());
@@ -587,11 +587,11 @@ namespace AzToolsFramework
 
     void ToolsApplication::MarkEntityDeselected(AZ::EntityId entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         auto foundIter = AZStd::find(m_selectedEntities.begin(), m_selectedEntities.end(), entityId);
         if (foundIter != m_selectedEntities.end())
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "ToolsApplication::MarkEntityDeselected:Deselect");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "ToolsApplication::MarkEntityDeselected:Deselect");
             ToolsApplicationEvents::Bus::Broadcast(&ToolsApplicationEvents::BeforeEntitySelectionChanged);
             m_selectedEntities.erase(foundIter);
 
@@ -603,7 +603,7 @@ namespace AzToolsFramework
 
     void ToolsApplication::MarkEntitiesDeselected(const EntityIdList& entitiesToDeselect)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         ToolsApplicationEvents::Bus::Broadcast(&ToolsApplicationEvents::BeforeEntitySelectionChanged);
 
@@ -633,14 +633,14 @@ namespace AzToolsFramework
 
     void ToolsApplication::SetEntityHighlighted(AZ::EntityId entityId, bool highlighted)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         auto foundIter = AZStd::find(m_highlightedEntities.begin(), m_highlightedEntities.end(), entityId);
         if (foundIter != m_highlightedEntities.end())
         {
             if (!highlighted)
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "ToolsApplication::SetEntityHighlighted:RemoveHighlight");
+                AZ_PROFILE_SCOPE(AzToolsFramework, "ToolsApplication::SetEntityHighlighted:RemoveHighlight");
                 ToolsApplicationEvents::Bus::Broadcast(&ToolsApplicationEvents::BeforeEntityHighlightingChanged);
                 m_highlightedEntities.erase(foundIter);
                 ToolsApplicationEvents::Bus::Broadcast(&ToolsApplicationEvents::AfterEntityHighlightingChanged);
@@ -648,7 +648,7 @@ namespace AzToolsFramework
         }
         else if (highlighted)
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "ToolsApplication::SetEntityHighlighted:AddHighlight");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "ToolsApplication::SetEntityHighlighted:AddHighlight");
             ToolsApplicationEvents::Bus::Broadcast(&ToolsApplicationEvents::BeforeEntityHighlightingChanged);
             m_highlightedEntities.push_back(entityId);
             ToolsApplicationEvents::Bus::Broadcast(&ToolsApplicationEvents::AfterEntityHighlightingChanged);
@@ -657,7 +657,7 @@ namespace AzToolsFramework
 
     void ToolsApplication::SetSelectedEntities(const EntityIdList& selectedEntities)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // We're setting the selection set as a batch from an external caller.
         // * Filter out any unselectable entities
@@ -1535,7 +1535,7 @@ namespace AzToolsFramework
 
     void ToolsApplication::CreateUndosForDirtyEntities()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AZ_Assert(!m_isDuringUndoRedo, "Cannot add dirty entities during undo/redo.");
         if (m_dirtyEntities.empty())
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Commands/EntityStateCommand.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Commands/EntityStateCommand.cpp
index 9f251bee7a..b73e1ea5ac 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Commands/EntityStateCommand.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Commands/EntityStateCommand.cpp
@@ -54,7 +54,7 @@ namespace AzToolsFramework
 
     void EntityStateCommand::Capture(AZ::Entity* pSourceEntity, bool captureUndo)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         m_entityID = pSourceEntity->GetId();
         EBUS_EVENT_ID_RESULT(m_entityContextId, m_entityID, AzFramework::EntityIdContextQueryBus, GetOwningContextId);
@@ -114,7 +114,7 @@ namespace AzToolsFramework
 
     void EntityStateCommand::RestoreEntity(const AZ::u8* buffer, AZStd::size_t bufferSizeBytes, const AZ::SliceComponent::EntityRestoreInfo& sliceRestoreInfo) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AZ_Assert(buffer, "No data to undo!");
         AZ_Assert(bufferSizeBytes, "Undo data is empty.");
@@ -259,7 +259,7 @@ namespace AzToolsFramework
 
     void EntityDeleteCommand::Redo()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         EBUS_EVENT(AZ::ComponentApplicationBus, DeleteEntity, m_entityID);
         PreemptiveUndoCache::Get()->PurgeCache(m_entityID);
     }
@@ -277,7 +277,7 @@ namespace AzToolsFramework
 
     void EntityCreateCommand::Undo()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         EBUS_EVENT(AZ::ComponentApplicationBus, DeleteEntity, m_entityID);
         PreemptiveUndoCache::Get()->PurgeCache(m_entityID);
     }
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Commands/PreemptiveUndoCache.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Commands/PreemptiveUndoCache.cpp
index 4d84089a74..d4c4fa1e65 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Commands/PreemptiveUndoCache.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Commands/PreemptiveUndoCache.cpp
@@ -86,7 +86,7 @@ namespace AzToolsFramework
 
     void PreemptiveUndoCache::UpdateCache(const AZ::EntityId& entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // capture it
 
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/EditorEntityContextComponent.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/EditorEntityContextComponent.cpp
index b45ffdd31d..90657132ca 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/EditorEntityContextComponent.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/EditorEntityContextComponent.cpp
@@ -312,7 +312,7 @@ namespace AzToolsFramework
                                                            EntityList& resultEntities,
                                                            EntityIdToEntityIdMap& sourceToCloneEntityIdMap)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         resultEntities.clear();
 
@@ -365,7 +365,7 @@ namespace AzToolsFramework
         const EntityList& entitiesInLayers,
         AZ::SliceComponent::SliceReferenceToInstancePtrs& instancesInLayers)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (m_isLegacySliceService)
         {
@@ -390,7 +390,7 @@ namespace AzToolsFramework
     //=========================================================================
     bool EditorEntityContextComponent::SaveToStreamForGame(AZ::IO::GenericStream& stream, AZ::DataStream::StreamType streamType)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         if (m_isLegacySliceService)
         {
             SliceEditorEntityOwnershipService* editorEntityOwnershipService =
@@ -409,7 +409,7 @@ namespace AzToolsFramework
     //=========================================================================
     bool EditorEntityContextComponent::LoadFromStream(AZ::IO::GenericStream& stream)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AZ_Assert(stream.IsOpen(), "Invalid source stream.");
         AZ_Assert(m_entityOwnershipService->IsInitialized(), "The context has not been initialized.");
@@ -427,7 +427,7 @@ namespace AzToolsFramework
 
     bool EditorEntityContextComponent::LoadFromStreamWithLayers(AZ::IO::GenericStream& stream, QString levelPakFile)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AZ_Assert(stream.IsOpen(), "Invalid source stream.");
         AZ_Assert(m_entityOwnershipService->IsInitialized(), "The context has not been initialized.");
@@ -477,7 +477,7 @@ namespace AzToolsFramework
     //=========================================================================
     void EditorEntityContextComponent::StartPlayInEditor()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         EditorEntityContextNotificationBus::Broadcast(&EditorEntityContextNotification::OnStartPlayInEditorBegin);
 
@@ -513,7 +513,7 @@ namespace AzToolsFramework
     //=========================================================================
     void EditorEntityContextComponent::StopPlayInEditor()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         m_isRunningGame = false;
 
@@ -696,13 +696,13 @@ namespace AzToolsFramework
     //=========================================================================
     void EditorEntityContextComponent::SetupEditorEntities(const EntityList& entities)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AZ::Data::AssetManager::Instance().SuspendAssetRelease();
 
         // All editor entities are automatically activated.
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "EditorEntityContextComponent::SetupEditorEntities:ScrubEntities");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "EditorEntityContextComponent::SetupEditorEntities:ScrubEntities");
 
             // Scrub entities before initialization.
             // Anything could go wrong with entities loaded from disk.
@@ -712,7 +712,7 @@ namespace AzToolsFramework
         }
 
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "EditorEntityContextComponent::SetupEditorEntities:InitEntities");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "EditorEntityContextComponent::SetupEditorEntities:InitEntities");
             for (AZ::Entity* entity : entities)
             {
                 if (entity->GetState() == AZ::Entity::State::Constructed)
@@ -723,7 +723,7 @@ namespace AzToolsFramework
         }
 
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "EditorEntityContextComponent::SetupEditorEntities:CreateEditorRepresentations");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "EditorEntityContextComponent::SetupEditorEntities:CreateEditorRepresentations");
             for (AZ::Entity* entity : entities)
             {
                 EditorRequests::Bus::Broadcast(&EditorRequests::CreateEditorRepresentation, entity);
@@ -731,7 +731,7 @@ namespace AzToolsFramework
         }
 
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "EditorEntityContextComponent::SetupEditorEntities:ActivateEntities");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "EditorEntityContextComponent::SetupEditorEntities:ActivateEntities");
             for (AZ::Entity* entity : entities)
             {
                 if (entity->GetState() == AZ::Entity::State::Init)
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/EditorEntityHelpers.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/EditorEntityHelpers.cpp
index 17ea732103..0b0358d613 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/EditorEntityHelpers.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/EditorEntityHelpers.cpp
@@ -323,7 +323,7 @@ namespace AzToolsFramework
 
     void AddEntityIdToSortInfo(const AZ::EntityId parentId, const AZ::EntityId childId, bool forceAddToBack)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         AZ::EntityId sortEntityId = GetEntityIdForSortInfo(parentId);
 
         bool success = false;
@@ -336,7 +336,7 @@ namespace AzToolsFramework
 
     void AddEntityIdToSortInfo(const AZ::EntityId parentId, const AZ::EntityId childId, const AZ::EntityId beforeEntity)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         AZ::EntityId sortEntityId = GetEntityIdForSortInfo(parentId);
 
         bool success = false;
@@ -349,7 +349,7 @@ namespace AzToolsFramework
 
     bool RecoverEntitySortInfo(const AZ::EntityId parentId, const AZ::EntityId childId, AZ::u64 sortIndex)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         EntityOrderArray entityOrderArray;
         EditorEntitySortRequestBus::EventResult(entityOrderArray, GetEntityIdForSortInfo(parentId), &EditorEntitySortRequestBus::Events::GetChildEntityOrderArray);
@@ -372,7 +372,7 @@ namespace AzToolsFramework
 
     void RemoveEntityIdFromSortInfo(const AZ::EntityId parentId, const AZ::EntityId childId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         AZ::EntityId sortEntityId = GetEntityIdForSortInfo(parentId);
 
         bool success = false;
@@ -385,7 +385,7 @@ namespace AzToolsFramework
 
     bool SetEntityChildOrder(const AZ::EntityId parentId, const EntityIdList& children)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         auto sortEntityId = GetEntityIdForSortInfo(parentId);
 
         bool success = false;
@@ -399,7 +399,7 @@ namespace AzToolsFramework
 
     EntityIdList GetEntityChildOrder(const AZ::EntityId parentId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         EntityIdList children;
         EditorEntityInfoRequestBus::EventResult(children, parentId, &EditorEntityInfoRequestBus::Events::GetChildren);
 
@@ -441,7 +441,7 @@ namespace AzToolsFramework
     //sort vector of entities by how they're arranged
     void SortEntitiesByLocationInHierarchy(EntityIdList& entityIds)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         //cache locations for faster sort
         AZStd::unordered_map<AZ::EntityId, AZStd::list<AZ::u64>> locations;
         for (auto entityId : entityIds)
@@ -575,7 +575,7 @@ namespace AzToolsFramework
 
     bool IsSelected(const AZ::EntityId entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         bool selected = false;
         EditorEntityInfoRequestBus::EventResult(
@@ -585,7 +585,7 @@ namespace AzToolsFramework
 
     bool IsSelectableInViewport(const AZ::EntityId entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         bool visible = false;
         EditorEntityInfoRequestBus::EventResult(
@@ -602,7 +602,7 @@ namespace AzToolsFramework
         const AZ::EntityId entityId, const bool locked,
         const AZ::EntityId toggledEntityId, const bool toggledEntityWasLayer)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (!entityId.IsValid())
         {
@@ -661,7 +661,7 @@ namespace AzToolsFramework
     // note: must be called on layer entity
     static void UnlockLayer(const AZ::EntityId entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         EditorLockComponentRequestBus::Event(
             entityId, &EditorLockComponentRequestBus::Events::SetLocked, false);
@@ -698,7 +698,7 @@ namespace AzToolsFramework
 
     void SetEntityLockState(const AZ::EntityId entityId, const bool locked)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // when an entity is unlocked, if it was in a locked layer(s), unlock those layers
         if (!locked)
@@ -736,7 +736,7 @@ namespace AzToolsFramework
 
     void ToggleEntityLockState(const AZ::EntityId entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (entityId.IsValid())
         {
@@ -772,7 +772,7 @@ namespace AzToolsFramework
 
     static void SetEntityVisibilityInternal(const AZ::EntityId entityId, const bool visibility)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         bool layerEntity = false;
         Layers::EditorLayerComponentRequestBus::EventResult(
@@ -795,7 +795,7 @@ namespace AzToolsFramework
     // note: must be called on layer entity
     static void ShowLayer(const AZ::EntityId entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         SetEntityVisibilityInternal(entityId, true);
 
@@ -830,7 +830,7 @@ namespace AzToolsFramework
         const AZ::EntityId entityId, const bool visible,
         const AZ::EntityId toggledEntityId, const bool toggledEntityWasLayer)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (!entityId.IsValid())
         {
@@ -879,7 +879,7 @@ namespace AzToolsFramework
 
     void SetEntityVisibility(const AZ::EntityId entityId, const bool visible)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // when an entity is set to visible, if it was in an invisible layer(s), make that layer visible
         if (visible)
@@ -917,7 +917,7 @@ namespace AzToolsFramework
 
     void ToggleEntityVisibility(const AZ::EntityId entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (entityId.IsValid())
         {
@@ -969,7 +969,7 @@ namespace AzToolsFramework
 
     bool IsEntitySetToBeVisible(const AZ::EntityId entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // Visibility state is tracked in 5 places, see OutlinerListModel::dataForLock for info on 3 of these ways.
         // Visibility's fourth state over lock is the EditorVisibilityRequestBus has two sets of
@@ -1007,7 +1007,7 @@ namespace AzToolsFramework
 
     AZ::Vector3 GetWorldTranslation(const AZ::EntityId entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AZ::Vector3 worldTranslation = AZ::Vector3::CreateZero();
         AZ::TransformBus::EventResult(
@@ -1018,7 +1018,7 @@ namespace AzToolsFramework
 
     AZ::Vector3 GetLocalTranslation(const AZ::EntityId entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AZ::Vector3 localTranslation = AZ::Vector3::CreateZero();
         AZ::TransformBus::EventResult(
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/EditorEntityModel.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/EditorEntityModel.cpp
index 860c12b11a..8d96cc42fe 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/EditorEntityModel.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/EditorEntityModel.cpp
@@ -38,7 +38,7 @@ namespace
     bool HasDifferences(T* sourceElem, T* compareElem, bool isRoot,
         AZ::SerializeContext* serializeContext)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (!sourceElem || !compareElem)
         {
@@ -146,7 +146,7 @@ namespace AzToolsFramework
     void EditorEntityModel::Reset()
     {
         m_preparingForContextReset = false;
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         //disconnect all entity ids
         EditorEntitySortNotificationBus::MultiHandler::BusDisconnect();
 
@@ -209,7 +209,7 @@ namespace AzToolsFramework
         sortedEntitiesToAdd.reserve(unsortedEntitiesToAdd.size());
 
         { // Sort pending entities
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "EditorEntityModel::AddEntityBatch:Sort");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "EditorEntityModel::AddEntityBatch:Sort");
 
             // Gather basic sorting data for each pending entity and
             // create map from parent ID to child entries.
@@ -307,7 +307,7 @@ namespace AzToolsFramework
         }
 
         { // Add sorted entities
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "EditorEntityModel::AddEntityBatch:Add");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "EditorEntityModel::AddEntityBatch:Add");
             for (AZ::EntityId entityId : sortedEntitiesToAdd)
             {
                 AddEntity(entityId);
@@ -325,7 +325,7 @@ namespace AzToolsFramework
 
     void EditorEntityModel::AddEntity(AZ::EntityId entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         auto& entityInfo = GetInfo(entityId);
 
         //initialize and connect this entry to the entity id
@@ -374,7 +374,7 @@ namespace AzToolsFramework
             // Skip doing slow, unecessary work for this bulk operations.
             return;
         }
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         auto& entityInfo = GetInfo(entityId);
         if (!entityInfo.IsConnected())
         {
@@ -404,7 +404,7 @@ namespace AzToolsFramework
 
     void EditorEntityModel::AddChildToParent(AZ::EntityId parentId, AZ::EntityId childId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         AZ_Assert(childId != parentId, "AddChildToParent called with same child and parent");
         if (childId == parentId || !childId.IsValid())
         {
@@ -479,7 +479,7 @@ namespace AzToolsFramework
 
     void EditorEntityModel::RemoveChildFromParent(AZ::EntityId parentId, AZ::EntityId childId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         AZ_Assert(childId != parentId, "RemoveChildFromparent called with same child and parent");
         AZ_Assert(childId.IsValid(), "RemoveChildFromparent called with an invalid child entity id");
         if (childId == parentId || !childId.IsValid())
@@ -544,7 +544,7 @@ namespace AzToolsFramework
 
     void EditorEntityModel::ReparentChild(AZ::EntityId entityId, AZ::EntityId newParentId, AZ::EntityId oldParentId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         AZ_Assert(oldParentId != entityId, "ReparentChild gave us an oldParentId that is the same as the entityId. An entity cannot be a parent of itself, ignoring old parent");
         AZ_Assert(newParentId != entityId, "ReparentChild gave us an newParentId that is the same as the entityId. An entity cannot be a parent of itself, ignoring old parent");
         if (oldParentId != entityId && newParentId != entityId)
@@ -573,7 +573,7 @@ namespace AzToolsFramework
 
     void EditorEntityModel::EntityRegistered(AZ::EntityId entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         //when an editor entity is created and registered, add it to a pending list.
         //once all entities in the pending list are activated, add them to model.
         bool isEditorEntity = false;
@@ -591,7 +591,7 @@ namespace AzToolsFramework
 
     void EditorEntityModel::EntityDeregistered(AZ::EntityId entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         //when an editor entity is de-registered, stop tracking it
         if (m_entityInfoTable.find(entityId) != m_entityInfoTable.end())
         {
@@ -628,7 +628,7 @@ namespace AzToolsFramework
 
     void EditorEntityModel::EntityParentChanged(AZ::EntityId entityId, AZ::EntityId newParentId, AZ::EntityId oldParentId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         if (GetInfo(entityId).IsConnected())
         {
             ReparentChild(entityId, newParentId, oldParentId);
@@ -647,7 +647,7 @@ namespace AzToolsFramework
 
     void EditorEntityModel::ChildEntityOrderArrayUpdated()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         //when notified that a parent has reordered its children, they must be updated
         if (m_enableChildReorderHandler)
         {
@@ -671,14 +671,14 @@ namespace AzToolsFramework
 
     void EditorEntityModel::OnEditorEntitiesPromotedToSlicedEntities(const AzToolsFramework::EntityIdList& promotedEntities)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         OnEditorEntitiesSliceOwnershipChanged(promotedEntities);
     }
 
     void EditorEntityModel::OnEditorEntitiesSliceOwnershipChanged(const AzToolsFramework::EntityIdList& entityIdList)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // Need to update slice info from top of hierarchy down
         // as parent entity slice status will be querried and needs to be correct
@@ -712,7 +712,7 @@ namespace AzToolsFramework
 
     void EditorEntityModel::OnEntityStreamLoadSuccess()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         //block internal reorder event handling to avoid recursion since we're manually updating everything
         m_enableChildReorderHandler = false;
@@ -722,7 +722,7 @@ namespace AzToolsFramework
 
         //refresh all order info while blocking related events (keeps UI observers from updating until refresh is complete)
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "EditorEntityModel::OnEntityStreamLoadSuccess:UpdateChildOrderInfo");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "EditorEntityModel::OnEntityStreamLoadSuccess:UpdateChildOrderInfo");
             for (auto& entityInfoPair : m_entityInfoTable)
             {
                 if (entityInfoPair.second.IsConnected())
@@ -733,7 +733,7 @@ namespace AzToolsFramework
             }
         }
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "EditorEntityModel::OnEntityStreamLoadSuccess:UpdateOrderInfo");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "EditorEntityModel::OnEntityStreamLoadSuccess:UpdateOrderInfo");
             for (auto& entityInfoPair : m_entityInfoTable)
             {
                 if (entityInfoPair.second.IsConnected())
@@ -778,7 +778,7 @@ namespace AzToolsFramework
 
     void EditorEntityModel::OnEntityTransformChanged(const AzToolsFramework::EntityIdList& entityIds)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         for (const AZ::EntityId& entityId : entityIds)
         {
@@ -846,7 +846,7 @@ namespace AzToolsFramework
 
     void EditorEntityModel::UpdateSliceInfoHierarchy(AZ::EntityId entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         auto& entityInfo = GetInfo(entityId);
         entityInfo.UpdateOrderInfo(false);
         entityInfo.UpdateSliceInfo();
@@ -896,7 +896,7 @@ namespace AzToolsFramework
 
     void EditorEntityModel::EditorEntityModelEntry::Connect()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         Disconnect();
 
         EntityInfoRequestConnect();
@@ -946,7 +946,7 @@ namespace AzToolsFramework
 
     void EditorEntityModel::EditorEntityModelEntry::UpdateSliceInfo()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         //reset slice info
         m_sliceFlags = (m_sliceFlags & SliceFlag_OverridesMask); // only hold on to the override flags
@@ -1037,7 +1037,7 @@ namespace AzToolsFramework
 
     void EditorEntityModel::EditorEntityModelEntry::UpdateOrderInfo(bool notify)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         AZ::u64 oldIndex = m_indexForSorting;
         AZ::u64 newIndex = 0;
 
@@ -1061,7 +1061,7 @@ namespace AzToolsFramework
 
     void EditorEntityModel::EditorEntityModelEntry::UpdateChildOrderInfo(bool forceAddToBack)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         //add order info if missing
         for (auto childId : m_children)
         {
@@ -1475,7 +1475,7 @@ namespace AzToolsFramework
 
     void EditorEntityModel::EditorEntityModelEntry::OnEntityLockFlagChanged(bool locked)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (m_locked != locked)
         {
@@ -1493,7 +1493,7 @@ namespace AzToolsFramework
 
     void EditorEntityModel::EditorEntityModelEntry::OnEntityVisibilityFlagChanged(bool visibility)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (m_visible != visibility)
         {
@@ -1511,7 +1511,7 @@ namespace AzToolsFramework
 
     void EditorEntityModel::EditorEntityModelEntry::OnSelected()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         if (!m_selected)
         {
             m_selected = true;
@@ -1522,7 +1522,7 @@ namespace AzToolsFramework
 
     void EditorEntityModel::EditorEntityModelEntry::OnDeselected()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         if (m_selected)
         {
             m_selected = false;
@@ -1533,7 +1533,7 @@ namespace AzToolsFramework
 
     void EditorEntityModel::EditorEntityModelEntry::OnEntityNameChanged(const AZStd::string& name)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         if (m_name != name)
         {
             m_name = name;
@@ -1554,7 +1554,7 @@ namespace AzToolsFramework
     {
         if (CanProcessOverrides())
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             using TransformComponent = AzToolsFramework::Components::TransformComponent;
 
@@ -1569,7 +1569,7 @@ namespace AzToolsFramework
     {
         if (CanProcessOverrides())
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             using EditorInspectorComponent = AzToolsFramework::Components::EditorInspectorComponent;
 
@@ -1584,7 +1584,7 @@ namespace AzToolsFramework
     {
         if (CanProcessOverrides())
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             AZ::Component* liveComponent = m_entity->FindComponent(componentId);
             AZ::Component* sourceComponent = m_sourceClone->FindComponent(componentId);
@@ -1804,7 +1804,7 @@ namespace AzToolsFramework
             return;
         }
 
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AZ::u8 lastFlags = m_sliceFlags;
 
@@ -1884,7 +1884,7 @@ namespace AzToolsFramework
 
     void EditorEntityModel::EditorEntityModelEntry::ModifyParentsOverriddenChildren(AZ::EntityId childEntityId, AZ::u8 lastFlags, bool childHasOverrides)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (((lastFlags & SliceFlag_EntityHasOverrides) == 0) != ((m_sliceFlags & SliceFlag_EntityHasOverrides) == 0))
         {
@@ -1916,7 +1916,7 @@ namespace AzToolsFramework
 
     void EditorEntityModel::EditorEntityModelEntry::UpdateCyclicDependencyInfo()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // Only check cyclic dependency if the current entity is a slice root
         if (!IsSliceRoot())
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/EditorEntitySortComponent.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/EditorEntitySortComponent.cpp
index 0e53c180d4..b747469f4d 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/EditorEntitySortComponent.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/EditorEntitySortComponent.cpp
@@ -130,7 +130,7 @@ namespace AzToolsFramework
 
         bool EditorEntitySortComponent::SetChildEntityOrderArray(const EntityOrderArray& entityOrderArray)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
             if (m_childEntityOrderArray != entityOrderArray)
             {
                 m_childEntityOrderArray = entityOrderArray;
@@ -143,7 +143,7 @@ namespace AzToolsFramework
 
         bool EditorEntitySortComponent::AddChildEntityInternal(const AZ::EntityId& entityId, bool addToBack, EntityOrderArray::iterator insertPosition)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
             auto entityItr = m_childEntityOrderCache.find(entityId);
             if (entityItr == m_childEntityOrderCache.end())
             {
@@ -197,7 +197,7 @@ namespace AzToolsFramework
 
         bool EditorEntitySortComponent::RemoveChildEntity(const AZ::EntityId& entityId)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
             auto entityItr = m_childEntityOrderCache.find(entityId);
             if (entityItr != m_childEntityOrderCache.end())
             {
@@ -222,7 +222,7 @@ namespace AzToolsFramework
 
         void EditorEntitySortComponent::OnEntityStreamLoadSuccess()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             m_childEntityOrderCache.clear();
             if (!m_childEntityOrderArray.empty())
@@ -320,7 +320,7 @@ namespace AzToolsFramework
 
         void EditorEntitySortComponent::RebuildEntityOrderCache()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
             m_childEntityOrderCache.clear();
             for (auto entityId : m_childEntityOrderArray)
             {
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/SliceEditorEntityOwnershipService.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/SliceEditorEntityOwnershipService.cpp
index e22800498c..7ac3b7be8f 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/SliceEditorEntityOwnershipService.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Entity/SliceEditorEntityOwnershipService.cpp
@@ -77,7 +77,7 @@ namespace AzToolsFramework
     AzFramework::SliceInstantiationTicket SliceEditorEntityOwnershipService::InstantiateEditorSlice(
         const AZ::Data::Asset<AZ::Data::AssetData>& sliceAsset, const AZ::Transform& worldTransform)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (sliceAsset.GetId().IsValid())
         {
@@ -97,7 +97,7 @@ namespace AzToolsFramework
 
     void SliceEditorEntityOwnershipService::OnSlicePreInstantiate(const AZ::Data::AssetId& sliceAssetId, const AZ::SliceComponent::SliceInstanceAddress& sliceAddress)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         const AzFramework::SliceInstantiationTicket ticket = *AzFramework::SliceInstantiationResultBus::GetCurrentBusId();
 
         // Start an undo that will wrap the entire slice instantiation event (unable to do this at a higher level since this is queued up by AzFramework and there's no undo concept at that level)
@@ -134,7 +134,7 @@ namespace AzToolsFramework
 
     void SliceEditorEntityOwnershipService::OnSliceInstantiated(const AZ::Data::AssetId& sliceAssetId, const AZ::SliceComponent::SliceInstanceAddress& sliceAddress)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const AzFramework::SliceInstantiationTicket ticket = *AzFramework::SliceInstantiationResultBus::GetCurrentBusId();
 
@@ -149,7 +149,7 @@ namespace AzToolsFramework
         // Close out the next ticket corresponding to this asset.
         for (auto instantiatingIter = m_instantiatingSlices.begin(); instantiatingIter != m_instantiatingSlices.end(); ++instantiatingIter)
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "EditorEntityContextComponent::OnSliceInstantiated:CloseTicket");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "EditorEntityContextComponent::OnSliceInstantiated:CloseTicket");
             if (instantiatingIter->first.GetId() == sliceAssetId)
             {
                 const AZ::SliceComponent::EntityList& entities = sliceAddressCopy.GetInstance()->GetInstantiated()->m_entities;
@@ -165,7 +165,7 @@ namespace AzToolsFramework
 
                 // Create a slice instantiation undo command.
                 {
-                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "EditorEntityContextComponent::OnSliceInstantiated:CloseTicket:CreateInstantiateUndo");
+                    AZ_PROFILE_SCOPE(AzToolsFramework, "EditorEntityContextComponent::OnSliceInstantiated:CloseTicket:CreateInstantiateUndo");
                     ScopedUndoBatch undoBatch("Instantiate Slice");
                     for (AZ::Entity* entity : entities)
                     {
@@ -192,7 +192,7 @@ namespace AzToolsFramework
 
     void SliceEditorEntityOwnershipService::OnSliceInstantiationFailed(const AZ::Data::AssetId& sliceAssetId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const AzFramework::SliceInstantiationTicket ticket = *AzFramework::SliceInstantiationResultBus::GetCurrentBusId();
 
@@ -214,7 +214,7 @@ namespace AzToolsFramework
     AZ::SliceComponent::SliceInstanceAddress SliceEditorEntityOwnershipService::CloneEditorSliceInstance(
         AZ::SliceComponent::SliceInstanceAddress sourceInstance, AZ::SliceComponent::EntityIdToEntityIdMap& sourceToCloneEntityIdMap)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (sourceInstance.IsValid())
         {
@@ -330,7 +330,7 @@ namespace AzToolsFramework
 
     void SliceEditorEntityOwnershipService::DetachSliceInstances(const AZ::SliceComponent::SliceInstanceAddressSet& instances)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const char* undoMsg = instances.size() == 1 ? "Detach Instance from Slice" : "Detach Instances from Slice";
 
@@ -359,7 +359,7 @@ namespace AzToolsFramework
 
     void SliceEditorEntityOwnershipService::DetachSubsliceInstances(const AZ::SliceComponent::SliceInstanceEntityIdRemapList& subsliceRootList)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (subsliceRootList.empty())
         {
@@ -379,7 +379,7 @@ namespace AzToolsFramework
 
     void SliceEditorEntityOwnershipService::DetachFromSlice(const AzToolsFramework::EntityIdList& entities, const char* undoMessage)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (entities.empty())
         {
@@ -424,7 +424,7 @@ namespace AzToolsFramework
 
     void SliceEditorEntityOwnershipService::OnAssetReady(AZ::Data::Asset<AZ::Data::AssetData> asset)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AZ::Data::AssetBus::MultiHandler::BusDisconnect(asset.GetId());
 
@@ -511,7 +511,7 @@ namespace AzToolsFramework
     //=========================================================================
     void SliceEditorEntityOwnershipService::OnAssetReloaded(AZ::Data::Asset<AZ::Data::AssetData> asset)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         EntityIdList selectedEntities;
         ToolsApplicationRequests::Bus::BroadcastResult(selectedEntities, &ToolsApplicationRequests::GetSelectedEntities);
@@ -524,7 +524,7 @@ namespace AzToolsFramework
 
     void SliceEditorEntityOwnershipService::ResetEntitiesToSliceDefaults(EntityIdList entities)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         ScopedUndoBatch undoBatch("Resetting entities to slice defaults.");
 
         PreemptiveUndoCache* preemptiveUndoCache = nullptr;
@@ -646,7 +646,7 @@ namespace AzToolsFramework
     bool SliceEditorEntityOwnershipService::SaveToStreamForEditor(AZ::IO::GenericStream& stream, const EntityList& entitiesInLayers,
         AZ::SliceComponent::SliceReferenceToInstancePtrs& instancesInLayers)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AZ_Assert(stream.IsOpen(), "Invalid target stream.");
         AzFramework::RootSliceAsset rootSliceAsset = GetRootAsset();
@@ -685,7 +685,7 @@ namespace AzToolsFramework
 
     bool SliceEditorEntityOwnershipService::SaveToStreamForGame(AZ::IO::GenericStream& stream, AZ::DataStream::StreamType streamType)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AZ::SliceComponent::EntityList sourceEntities;
         GetRootSlice()->GetEntities(sourceEntities);
@@ -929,7 +929,7 @@ namespace AzToolsFramework
 
     bool SliceEditorEntityOwnershipService::LoadFromStreamWithLayers(AZ::IO::GenericStream& stream, QString levelPakFile)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AZ::ObjectStream::FilterDescriptor filterDesc = AZ::ObjectStream::FilterDescriptor(&AZ::Data::AssetFilterSourceSlicesOnly);
 
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/BaseManipulator.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/BaseManipulator.cpp
index 1a7e7260c5..b514c3957f 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/BaseManipulator.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/BaseManipulator.cpp
@@ -33,7 +33,7 @@ namespace AzToolsFramework
 
     bool BaseManipulator::OnLeftMouseDown(const ViewportInteraction::MouseInteraction& interaction, const float rayIntersectionDistance)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (m_onLeftMouseDownImpl)
         {
@@ -59,7 +59,7 @@ namespace AzToolsFramework
 
     bool BaseManipulator::OnRightMouseDown(const ViewportInteraction::MouseInteraction& interaction, const float rayIntersectionDistance)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (m_onRightMouseDownImpl)
         {
@@ -87,7 +87,7 @@ namespace AzToolsFramework
     // attached as no active manipulator will have been set in ManipulatorManager.
     void BaseManipulator::OnLeftMouseUp(const ViewportInteraction::MouseInteraction& interaction)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         SetBoundsDirty();
 
@@ -98,7 +98,7 @@ namespace AzToolsFramework
 
     void BaseManipulator::OnRightMouseUp(const ViewportInteraction::MouseInteraction& interaction)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         SetBoundsDirty();
 
@@ -109,7 +109,7 @@ namespace AzToolsFramework
 
     bool BaseManipulator::OnMouseOver(const ManipulatorId manipulatorId, const ViewportInteraction::MouseInteraction& interaction)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         UpdateMouseOver(manipulatorId);
         OnMouseOverImpl(manipulatorId, interaction);
@@ -125,7 +125,7 @@ namespace AzToolsFramework
 
     void BaseManipulator::OnMouseMove(const ViewportInteraction::MouseInteraction& interaction)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (!m_performingAction)
         {
@@ -142,7 +142,7 @@ namespace AzToolsFramework
 
     void BaseManipulator::SetBoundsDirty()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         SetBoundsDirtyImpl();
     }
@@ -190,7 +190,7 @@ namespace AzToolsFramework
 
     void BaseManipulator::EndAction()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (!m_performingAction)
         {
@@ -235,7 +235,7 @@ namespace AzToolsFramework
 
     void BaseManipulator::NotifyEntityComponentPropertyChanged()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         for (const AZ::EntityComponentIdPair& entityComponentIdPair : m_entityComponentIdPairs)
         {
@@ -268,7 +268,7 @@ namespace AzToolsFramework
 
     AZStd::unordered_set<AZ::EntityComponentIdPair>::iterator BaseManipulator::RemoveEntityId(const AZ::EntityId entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         auto afterErased = m_entityComponentIdPairs.end();
 
@@ -297,7 +297,7 @@ namespace AzToolsFramework
     AZStd::unordered_set<AZ::EntityComponentIdPair>::iterator BaseManipulator::RemoveEntityComponentIdPair(
         const AZ::EntityComponentIdPair& entityComponentIdPair)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const auto entityIdIt = m_entityComponentIdPairs.find(entityComponentIdPair);
 
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/EditorVertexSelection.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/EditorVertexSelection.cpp
index fa4fb9ad31..f49df5d029 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/EditorVertexSelection.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/EditorVertexSelection.cpp
@@ -147,7 +147,7 @@ namespace AzToolsFramework
         const AZ::Vector3& localManipulatorStartPosition,
         const AZ::Vector3& localManipulatorOffset)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // bind FixedVerticesRequestBus for improved performance
         typename AZ::FixedVerticesRequestBus<Vertex>::BusPtr fixedVertices;
@@ -180,7 +180,7 @@ namespace AzToolsFramework
     template<typename Vertex>
     void InitializeVertexLookup(IndexedTranslationManipulator<Vertex>& translationManipulator, const AZ::EntityId entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // bind FixedVerticesRequestBus for improved performance
         typename AZ::FixedVerticesRequestBus<Vertex>::BusPtr fixedVertices;
@@ -210,7 +210,7 @@ namespace AzToolsFramework
         const Vertex& vertex,
         size_t vertexIndex)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // if we have a vertex (translation) manipulator active, ensure
         // it gets removed when clicking on another selection manipulator
@@ -342,7 +342,7 @@ namespace AzToolsFramework
         const EditorBoxSelect& editorBoxSelect,
         const AZStd::vector<AZStd::shared_ptr<SelectionManipulator>>& selectionManipulators)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // refresh selection manipulators and box select data when modifiers change
         // (switching from additive to subtractive)
@@ -481,7 +481,7 @@ namespace AzToolsFramework
         const TranslationManipulators::Dimensions dimensions,
         const TranslationManipulatorConfiguratorFn translationManipulatorConfigurator)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         m_dimensions = dimensions;
         m_manipulatorManagerId = managerId;
@@ -705,7 +705,7 @@ namespace AzToolsFramework
     template<typename Vertex>
     void EditorVertexSelectionBase<Vertex>::ClearSelected()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // if translation manipulator is active, remove it when receiving this event and enable
         // the hover manipulator bounds again so points can be inserted again
@@ -736,7 +736,7 @@ namespace AzToolsFramework
     void EditorVertexSelectionBase<Vertex>::DisplayEntityViewport(
         const AzFramework::ViewportInfo& viewportInfo, AzFramework::DebugDisplayRequests& debugDisplay)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         m_editorBoxSelect.DisplayScene(viewportInfo, debugDisplay);
 
@@ -747,7 +747,7 @@ namespace AzToolsFramework
     void EditorVertexSelectionBase<Vertex>::DisplayViewport2d(
         const AzFramework::ViewportInfo& viewportInfo, AzFramework::DebugDisplayRequests& debugDisplay)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         m_editorBoxSelect.Display2d(viewportInfo, debugDisplay);
     }
@@ -756,7 +756,7 @@ namespace AzToolsFramework
     template<typename V, typename AZStd::enable_if<AZStd::is_same<V, AZ::Vector3>::value>::type*>
     void EditorVertexSelectionBase<Vertex>::UpdateManipulatorSpace(const AzFramework::ViewportInfo& viewportInfo)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // check if 'shift' is being held to move to parent space
         bool worldSpace = false;
@@ -803,7 +803,7 @@ namespace AzToolsFramework
     template<typename Vertex>
     void EditorVertexSelectionVariable<Vertex>::DestroySelected()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const AZ::EntityId entityId = EditorVertexSelectionBase<Vertex>::GetEntityId();
 
@@ -855,7 +855,7 @@ namespace AzToolsFramework
     template<typename Vertex>
     void EditorVertexSelectionBase<Vertex>::SetSelectedPosition(const AZ::Vector3& localPosition)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (m_translationManipulator)
         {
@@ -884,7 +884,7 @@ namespace AzToolsFramework
     template<typename Vertex>
     void EditorVertexSelectionBase<Vertex>::RefreshTranslationManipulator()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // bind FixedVerticesRequestBus for improved performance
         typename AZ::FixedVerticesRequestBus<Vertex>::BusPtr fixedVertices;
@@ -915,7 +915,7 @@ namespace AzToolsFramework
     template<typename Vertex>
     void EditorVertexSelectionBase<Vertex>::RefreshLocal()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // we do not want to refresh our local state while a batch movement is in progress,
         // even if we have been signalled to do so by a callback
@@ -955,7 +955,7 @@ namespace AzToolsFramework
     template<typename Vertex>
     void EditorVertexSelectionBase<Vertex>::RefreshSpace(const AZ::Transform& worldFromLocal, const AZ::Vector3& nonUniformScale)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         for (auto& manipulator : m_selectionManipulators)
         {
@@ -982,7 +982,7 @@ namespace AzToolsFramework
     template<typename Vertex>
     void EditorVertexSelectionBase<Vertex>::SetBoundsDirty()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         for (auto& manipulator : m_selectionManipulators)
         {
@@ -1008,7 +1008,7 @@ namespace AzToolsFramework
         const AZ::EntityComponentIdPair& entityComponentIdPair,
         const ManipulatorManagerId managerId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         Vertex vertex;
         bool found = false;
@@ -1078,7 +1078,7 @@ namespace AzToolsFramework
         const ManipulatorManagerId managerId,
         const size_t vertexIndex)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // setup selection manipulator
         const AZStd::shared_ptr<ManipulatorViewSphere> selectionView = AzToolsFramework::CreateManipulatorViewSphere(
@@ -1115,7 +1115,7 @@ namespace AzToolsFramework
         const ManipulatorManagerId managerId,
         const size_t vertexIndex)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // setup selection manipulator
         const AZStd::shared_ptr<ManipulatorViewSphere> manipulatorView = AzToolsFramework::CreateManipulatorViewSphere(
@@ -1223,7 +1223,7 @@ namespace AzToolsFramework
     Vertex EditorVertexSelectionVariable<Vertex>::InsertSelectedInPlace(
         AZStd::vector<typename IndexedTranslationManipulator<Vertex>::VertexLookup>& manipulators)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // utility to calculate the center point of the selected vertices after duplication
         MidpointCalculator midpointCalculator;
@@ -1267,7 +1267,7 @@ namespace AzToolsFramework
     template<typename Vertex>
     void EditorVertexSelectionVariable<Vertex>::DuplicateSelected()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         ScopedUndoBatch duplicateUndo("Duplicate Vertices");
         ScopedUndoBatch::MarkEntityDirty(EditorVertexSelectionBase<Vertex>::GetEntityId());
@@ -1346,7 +1346,7 @@ namespace AzToolsFramework
     template<typename Vertex>
     void InsertVertexAfter(const AZ::EntityComponentIdPair& entityComponentIdPair, const size_t vertexIndex, const Vertex& localPosition)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         size_t size = 0;
         AZ::VariableVerticesRequestBus<Vertex>::EventResult(
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ManipulatorManager.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ManipulatorManager.cpp
index e994e8e2cd..b07ac08d87 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ManipulatorManager.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ManipulatorManager.cpp
@@ -74,7 +74,7 @@ namespace AzToolsFramework
     Picking::RegisteredBoundId ManipulatorManager::UpdateBound(
         const ManipulatorId manipulatorId, const Picking::RegisteredBoundId boundId, const Picking::BoundRequestShapeBase& boundShapeData)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (manipulatorId == InvalidManipulatorId)
         {
@@ -124,7 +124,7 @@ namespace AzToolsFramework
 
     void ManipulatorManager::RefreshMouseOverState(const ViewportInteraction::MousePick& mousePick)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (!Interacting())
         {
@@ -142,7 +142,7 @@ namespace AzToolsFramework
         const AzFramework::CameraState& cameraState,
         const ViewportInteraction::MouseInteraction& mouseInteraction)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         for (const auto& pair : m_manipulatorIdToPtrMap)
         {
@@ -155,7 +155,7 @@ namespace AzToolsFramework
     AZStd::shared_ptr<BaseManipulator> ManipulatorManager::PerformRaycast(
         const AZ::Vector3& rayOrigin, const AZ::Vector3& rayDirection, float& rayIntersectionDistance)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         Picking::RaySelectInfo raySelection;
         raySelection.m_origin = rayOrigin;
@@ -255,7 +255,7 @@ namespace AzToolsFramework
     ManipulatorManager::ConsumeMouseMoveResult ManipulatorManager::ConsumeViewportMouseMove(
         const ViewportInteraction::MouseInteraction& interaction)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (m_activeManipulator)
         {
@@ -279,7 +279,7 @@ namespace AzToolsFramework
 
     void ManipulatorManager::OnEntityInfoUpdatedVisibility(const AZ::EntityId entityId, const bool visible)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         for (auto& pair : m_manipulatorIdToPtrMap)
         {
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp
index e618a11344..cdb1e9a2ad 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp
@@ -996,12 +996,12 @@ namespace AzToolsFramework
             // the full nested hierarchy with what is returned from RetrieveAndSortPrefabEntitiesAndInstances
             AzToolsFramework::EntityIdSet duplicationSet = AzToolsFramework::GetCulledEntityHierarchy(entityIdsNoLevelInstance);
 
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             ScopedUndoBatch undoBatch("Duplicate Entities");
 
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "DuplicateEntitiesInInstance::UndoCaptureAndDuplicateEntities");
+                AZ_PROFILE_SCOPE(AzToolsFramework, "DuplicateEntitiesInInstance::UndoCaptureAndDuplicateEntities");
 
                 AZStd::vector<AZ::Entity*> entities;
                 AZStd::vector<Instance*> instances;
@@ -1123,7 +1123,7 @@ namespace AzToolsFramework
             // Retrieve entityList from entityIds
             EntityList inputEntityList = EntityIdListToEntityList(entityIdsNoLevelInstance);
 
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             ScopedUndoBatch undoBatch("Delete Selected");
 
@@ -1145,7 +1145,7 @@ namespace AzToolsFramework
             }
 
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "Internal::DeleteEntities:UndoCaptureAndPurgeEntities");
+                AZ_PROFILE_SCOPE(AzToolsFramework, "Internal::DeleteEntities:UndoCaptureAndPurgeEntities");
 
                 Prefab::PrefabDom instanceDomBefore;
                 m_instanceToTemplateInterface->GenerateDomForInstance(instanceDomBefore, commonOwningInstance->get());
@@ -1205,7 +1205,7 @@ namespace AzToolsFramework
 
             selCommand->SetParent(undoBatch.GetUndoBatch());
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "Internal::DeleteEntities:RunRedo");
+                AZ_PROFILE_SCOPE(AzToolsFramework, "Internal::DeleteEntities:RunRedo");
                 selCommand->RunRedo();
             }
 
@@ -1230,10 +1230,10 @@ namespace AzToolsFramework
                 return AZ::Failure(AZStd::string("Input entity should be its owning Instance's container entity."));
             }
 
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "Internal::DetachPrefab:UndoCapture");
+                AZ_PROFILE_SCOPE(AzToolsFramework, "Internal::DetachPrefab:UndoCapture");
 
                 ScopedUndoBatch undoBatch("Detach Prefab");
 
@@ -1294,7 +1294,7 @@ namespace AzToolsFramework
                     command->Capture(instanceDomBefore, instanceDomAfter, parentTemplateId);
                     command->SetParent(undoBatch.GetUndoBatch());
                     {
-                        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "Internal::DetachPrefab:RunRedo");
+                        AZ_PROFILE_SCOPE(AzToolsFramework, "Internal::DetachPrefab:RunRedo");
                         command->RunRedo();
                     }
 
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabUndoCache.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabUndoCache.cpp
index 3d22a35858..c83e0857a3 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabUndoCache.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabUndoCache.cpp
@@ -12,6 +12,7 @@
 #include <AzCore/Component/Entity.h>
 #include <AzCore/Component/TransformBus.h>
 #include <AzCore/Console/ILogger.h>
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/Interface/Interface.h>
 
 #include <AzFramework/API/ApplicationAPI.h>
@@ -111,7 +112,7 @@ namespace AzToolsFramework
 
         void PrefabUndoCache::UpdateCache(const AZ::EntityId& entityId)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             AZ::Entity* entity = nullptr;
             AZ::ComponentApplicationBus::BroadcastResult(entity, &AZ::ComponentApplicationRequests::FindEntity, entityId);
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Slice/SliceCompilation.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Slice/SliceCompilation.cpp
index 3c7bab3e77..e9825f6f14 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Slice/SliceCompilation.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Slice/SliceCompilation.cpp
@@ -274,7 +274,7 @@ namespace AzToolsFramework
      */
     SliceCompilationResult CompileEditorSlice(const AZ::Data::Asset<AZ::SliceAsset>& sourceSliceAsset, const AZ::PlatformTagSet& platformTags, AZ::SerializeContext& serializeContext, const EditorOnlyEntityHandlers& editorOnlyEntityHandlers)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         if (!sourceSliceAsset)
         {
             return AZ::Failure(AZStd::string("Source slice is invalid."));
@@ -657,7 +657,7 @@ namespace AzToolsFramework
     // tolerate ALL possible input errors (looping parents, invalid IDs, etc).
     void SortTransformParentsBeforeChildren(AZStd::vector<AZ::Entity*>& entities)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // IDs of those present in 'entities'. Does not include parent ID if parent not found in 'entities'
         AZStd::unordered_set<AZ::EntityId> existingEntityIds;
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Slice/SliceTransaction.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Slice/SliceTransaction.cpp
index 15b330c65b..d8b5fe0a15 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Slice/SliceTransaction.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Slice/SliceTransaction.cpp
@@ -63,7 +63,7 @@ namespace AzToolsFramework
 
                 void Capture(const SliceTransaction::SliceAssetPtr& before, const SliceTransaction::SliceAssetPtr& after, const char* sliceAssetPath)
                 {
-                    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+                    AZ_PROFILE_FUNCTION(AzToolsFramework);
 
                     m_sliceAssetPath = sliceAssetPath;
                     m_isNewAsset = !before.GetId().IsValid();
@@ -74,7 +74,7 @@ namespace AzToolsFramework
 
                     if (!m_isNewAsset)
                     {
-                        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "SliceUtilities::Internal::SaveSliceToDiskCommand::Capture:SaveBefore");
+                        AZ_PROFILE_SCOPE(AzToolsFramework, "SliceUtilities::Internal::SaveSliceToDiskCommand::Capture:SaveBefore");
                         AZ::SliceAsset* sliceBefore = before.Get();
                         AZ::Entity* sliceEntityBefore = sliceBefore->GetEntity();
                         AZ::IO::ByteContainerStream<ByteBuffer> beforeStream(&m_sliceAssetBeforeBuffer);
@@ -82,7 +82,7 @@ namespace AzToolsFramework
                     }
 
                     {
-                        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "SliceUtilities::Internal::SaveSliceToDiskCommand::Capture:SaveAfter");
+                        AZ_PROFILE_SCOPE(AzToolsFramework, "SliceUtilities::Internal::SaveSliceToDiskCommand::Capture:SaveAfter");
                         AZ::SliceAsset* sliceAfter = after.Get();
                         AZ::Entity* sliceEntityAfter = sliceAfter->GetEntity();
                         AZ::IO::ByteContainerStream<ByteBuffer> afterStream(&m_sliceAssetAfterBuffer);
@@ -105,13 +105,13 @@ namespace AzToolsFramework
 
                 void Redo() override
                 {
-                    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+                    AZ_PROFILE_FUNCTION(AzToolsFramework);
                     m_redoResult = Internal::SaveSliceToDisk(m_sliceAssetPath.c_str(), m_sliceAssetAfterBuffer);
                 }
 
                 void Undo() override
                 {
-                    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+                    AZ_PROFILE_FUNCTION(AzToolsFramework);
                     if (m_isNewAsset)
                     {
                         // New asset means we didn't have an existing asset, so we should instead remove the newly created asset as our undo
@@ -149,7 +149,7 @@ namespace AzToolsFramework
             AZ::SerializeContext* serializeContext,
             AZ::u32 sliceCreationFlags)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             if (!serializeContext)
             {
@@ -179,7 +179,7 @@ namespace AzToolsFramework
 
         SliceTransaction::TransactionPtr SliceTransaction::BeginSliceOverwrite(const SliceAssetPtr& asset,  const AZ::SliceComponent& overwriteComponent, AZ::SerializeContext* serializeContext)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             if (!serializeContext)
             {
@@ -212,7 +212,7 @@ namespace AzToolsFramework
             AZ::SerializeContext* serializeContext,
             AZ::u32 /*slicePushFlags*/)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             if (!serializeContext)
             {
@@ -515,7 +515,7 @@ namespace AzToolsFramework
             SliceTransaction::PostSaveCallback postSaveCallback,
             AZ::u32 sliceCommitFlags)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // Clone asset for final modifications and save.
             // This also releases borrowed entities and slice instances.
@@ -702,7 +702,7 @@ namespace AzToolsFramework
             SliceTransaction::PostSaveCallback postSaveCallback,
             AZ::u32 sliceCommitFlags)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             AZStd::string sliceAssetPath;
             AZ::Data::AssetCatalogRequestBus::BroadcastResult(sliceAssetPath, &AZ::Data::AssetCatalogRequests::GetAssetPathById, targetAssetId);
@@ -762,7 +762,7 @@ namespace AzToolsFramework
         //=========================================================================
         SliceTransaction::SliceAssetPtr SliceTransaction::CloneAssetForSave()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // Move included slice instances to the target asset temporarily so that they are included in the clone
             for (auto& addedSliceInstanceIt : m_addedSliceInstances)
@@ -868,7 +868,7 @@ namespace AzToolsFramework
         //=========================================================================
         SliceTransaction::Result SliceTransaction::PreSave(const char* fullPath, SliceAssetPtr& asset, PreSaveCallback preSaveCallback, AZ::u32 /*sliceCommitFlags*/)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // Remap live Ids back to those of the asset.
             AZ::EntityUtils::SerializableEntityContainer assetEntities;
@@ -904,7 +904,7 @@ namespace AzToolsFramework
         //=========================================================================
         AZ::EntityId SliceTransaction::FindTargetAncestorAndUpdateInstanceIdMap(AZ::EntityId entityId, AZ::SliceComponent::EntityIdToEntityIdMap& liveToAssetIdMap, const AZ::SliceComponent::SliceInstanceAddress* ignoreSliceInstance) const
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             AZ::SliceComponent* slice = m_targetAsset.Get()->GetComponent();
 
@@ -1036,7 +1036,7 @@ namespace AzToolsFramework
             //=========================================================================
             SliceTransaction::Result SaveSliceToDisk(const char* targetPath, AZStd::vector<AZ::u8>& sliceAssetEntityMemoryBuffer, AZ::SerializeContext* serializeContext)
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+                AZ_PROFILE_FUNCTION(AzToolsFramework);
 
                 AZ::IO::FileIOBase* fileIO = AZ::IO::FileIOBase::GetInstance();
                 AZ_Assert(fileIO, "File IO is not initialized.");
@@ -1058,7 +1058,7 @@ namespace AzToolsFramework
                     // Write the in-memory copy to file
                     bool savedToFile;
                     {
-                        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "SliceUtilities::Internal::SaveSliceToDisk:SaveToFileStream");
+                        AZ_PROFILE_SCOPE(AzToolsFramework, "SliceUtilities::Internal::SaveSliceToDisk:SaveToFileStream");
                         memoryStream.Seek(0, AZ::IO::GenericStream::ST_SEEK_BEGIN);
                         savedToFile = fileStream.Write(memoryStream.GetLength(), memoryStream.GetData()->data()) != 0;
                     }
@@ -1066,14 +1066,14 @@ namespace AzToolsFramework
 
                     if (savedToFile)
                     {
-                        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "SliceUtilities::Internal::SaveSliceToDisk:TempToTargetFileReplacement");
+                        AZ_PROFILE_SCOPE(AzToolsFramework, "SliceUtilities::Internal::SaveSliceToDisk:TempToTargetFileReplacement");
 
                         // Copy scratch file to target location.
                         const bool targetFileExists = fileIO->Exists(targetPath);
 
                         bool removedTargetFile;
                         {
-                            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "SliceUtilities::Internal::SaveSliceToDisk:TempToTargetFileReplacement:RemoveTarget");
+                            AZ_PROFILE_SCOPE(AzToolsFramework, "SliceUtilities::Internal::SaveSliceToDisk:TempToTargetFileReplacement:RemoveTarget");
                             removedTargetFile = fileIO->Remove(targetPath);
                         }
 
@@ -1083,7 +1083,7 @@ namespace AzToolsFramework
                         }
 
                         {
-                            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "SliceUtilities::Internal::SaveSliceToDisk:TempToTargetFileReplacement:RenameTempFile");
+                            AZ_PROFILE_SCOPE(AzToolsFramework, "SliceUtilities::Internal::SaveSliceToDisk:TempToTargetFileReplacement:RenameTempFile");
                             AZ::IO::Result renameResult = fileIO->Rename(tempFilePath.c_str(), targetPath);
                             if (!renameResult)
                             {
@@ -1093,7 +1093,7 @@ namespace AzToolsFramework
 
                         // Bump the slice asset up in the asset processor's queue.
                         {
-                            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "SliceUtilities::Internal::SaveSliceToDisk:TempToTargetFileReplacement:GetAssetStatus");
+                            AZ_PROFILE_SCOPE(AzToolsFramework, "SliceUtilities::Internal::SaveSliceToDisk:TempToTargetFileReplacement:GetAssetStatus");
                             EBUS_EVENT(AzFramework::AssetSystemRequestBus, EscalateAssetBySearchTerm, targetPath);
                         }
                         return AZ::Success();
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Slice/SliceUtilities.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Slice/SliceUtilities.cpp
index 6ef0c83991..02fc2c2c40 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Slice/SliceUtilities.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Slice/SliceUtilities.cpp
@@ -405,7 +405,7 @@ namespace AzToolsFramework
         bool QueryAndPruneMissingExternalReferences(AzToolsFramework::EntityIdSet& entities, AzToolsFramework::EntityIdSet& selectedAndReferencedEntities,
                     bool& useReferencedEntities, bool defaultMoveExternalRefs = false)
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "SliceUtilities::MakeNewSlice:HandleNotIncludedReferences");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "SliceUtilities::MakeNewSlice:HandleNotIncludedReferences");
             useReferencedEntities = false;
 
             AZStd::string includedEntities;
@@ -440,7 +440,7 @@ namespace AzToolsFramework
             {
                 if (!defaultMoveExternalRefs)
                 {
-                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "SliceUtilities::MakeNewSlice:HandleNotIncludedReferences:UserDialog");
+                    AZ_PROFILE_SCOPE(AzToolsFramework, "SliceUtilities::MakeNewSlice:HandleNotIncludedReferences:UserDialog");
 
                     const AZStd::string message = AZStd::string::format(
                         "Entity references may not be valid if the entity IDs change or if the entities do not exist when the slice is instantiated.\r\n\r\nSelected Entities\n%s\nReferenced Entities\n%s\n",
@@ -510,7 +510,7 @@ namespace AzToolsFramework
             while (true)
             {
                 {
-                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "SliceUtilities::MakeNewSlice:SaveAsDialog");
+                    AZ_PROFILE_SCOPE(AzToolsFramework, "SliceUtilities::MakeNewSlice:SaveAsDialog");
                     saveAs = QFileDialog::getSaveFileName(nullptr, QString("Save As..."), saveAsInitialSuggestedFullPath.c_str(), QString("Slices (*.slice)"));
                 }
 
@@ -608,7 +608,7 @@ namespace AzToolsFramework
                           bool silenceWarningPopups,
                           AZ::SerializeContext* serializeContext)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             if (entities.empty())
             {
@@ -702,7 +702,7 @@ namespace AzToolsFramework
             { 
                 if (inheritSlices)
                 {
-                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "SliceUtilities::MakeNewSlice:CloneExistingSliceEntities");
+                    AZ_PROFILE_SCOPE(AzToolsFramework, "SliceUtilities::MakeNewSlice:CloneExistingSliceEntities");
 
                     const AZ::EntityId dummyParentId;
 
@@ -801,14 +801,14 @@ namespace AzToolsFramework
             // Setup and execute transaction for the new slice.
             //
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "SliceUtilities::MakeNewSlice:SetupAndExecuteTransaction");
+                AZ_PROFILE_SCOPE(AzToolsFramework, "SliceUtilities::MakeNewSlice:SetupAndExecuteTransaction");
 
                 // PreSaveCallback for slice creation: Before saving slice, we ensure it has a single root by optionally auto-creating one for the user
                 SliceTransaction::PreSaveCallback preSaveCallback =
                     [&sliceName, &sliceRootEntityPosition, &sliceRootEntityRotation, &activeWindow, &defaultGenerateSharedRoot]
                     (SliceTransaction::TransactionPtr transaction, const char* fullPath, SliceTransaction::SliceAssetPtr& asset) -> SliceTransaction::Result
                     {
-                        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "SliceUtilities::MakeNewSlice:PreSaveCallback");
+                        AZ_PROFILE_SCOPE(AzToolsFramework, "SliceUtilities::MakeNewSlice:PreSaveCallback");
                         AZ::SliceComponent::EntityIdToEntityIdMap assetToLiveEntityIDMap;
                         const AZ::SliceComponent::EntityIdToEntityIdMap& liveToAssetEntityIDMap = transaction->GetLiveToAssetEntityIdMap();
 
@@ -855,7 +855,7 @@ namespace AzToolsFramework
 
                 // Add entities
                 {
-                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "SliceUtilities::MakeNewSlice:SetupAndExecuteTransaction:AddEntities");
+                    AZ_PROFILE_SCOPE(AzToolsFramework, "SliceUtilities::MakeNewSlice:SetupAndExecuteTransaction:AddEntities");
                     for (const AZ::EntityId& entityId : entitiesToIncludeInAsset)
                     {
                         SliceTransaction::Result addResult = transaction->AddEntity(entityId, !inheritSlices ? SliceTransaction::SliceAddEntityFlags::DiscardSliceAncestry : 0);
@@ -914,7 +914,7 @@ namespace AzToolsFramework
         void GatherAllReferencedEntities(AzToolsFramework::EntityIdSet& entitiesWithReferences,
                                          AZ::SerializeContext& serializeContext)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             AZStd::vector<AZ::EntityId> floodQueue;
             floodQueue.reserve(entitiesWithReferences.size());
@@ -1038,7 +1038,7 @@ namespace AzToolsFramework
                                                                     const AZ::SliceComponent::SliceInstance& instance,
                                                                     AZ::SerializeContext& serializeContext)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             AZ_Assert(instance.GetEntityIdMap().find(sourceEntity.GetId()) != instance.GetEntityIdMap().end(), "Provided source entity is not a member of the provided slice instance.");
 
@@ -1494,7 +1494,7 @@ namespace AzToolsFramework
         //=========================================================================
         SliceTransaction::Result SlicePreSaveCallbackForWorldEntities(SliceTransaction::TransactionPtr transaction, const char* fullPath, SliceTransaction::SliceAssetPtr& asset)
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "SliceUtilities::SlicePreSaveCallbackForWorldEntities");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "SliceUtilities::SlicePreSaveCallbackForWorldEntities");
 
             // Apply standard root transform rules. Zero out root entity translation, ensure single root, ensure slice root has no parent in slice.
             SliceTransaction::Result worldTransformRulesResult = VerifyAndApplySliceWorldTransformRules(asset);
@@ -1536,7 +1536,7 @@ namespace AzToolsFramework
 
         void SlicePostSaveCallbackForNewSlice(SliceTransaction::TransactionPtr transaction, const char* fullPath, const SliceTransaction::SliceAssetPtr& transactionAsset)
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "SliceUtilities::SlicePostSaveCallbackForNewSlice");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "SliceUtilities::SlicePostSaveCallbackForNewSlice");
 
             const char* undoMessage = "Create Slice Asset";
             ScopedUndoBatch undoBatch(undoMessage);
@@ -1568,7 +1568,7 @@ namespace AzToolsFramework
         bool CheckSliceAdditionCyclicDependencySafe(const AZ::SliceComponent::SliceInstanceAddress& instanceToAdd,
                                                     const AZ::SliceComponent::SliceInstanceAddress& targetInstanceToAddTo)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             AZ_Assert(instanceToAdd.IsValid(), "Invalid instanceToAdd passed to CheckSliceADditionCyclicDependencySafe.");
           
@@ -1706,7 +1706,7 @@ namespace AzToolsFramework
 
         void PopulateSliceSubMenus(QMenu& outerMenu, const AzToolsFramework::EntityIdList& inputEntities, SliceSelectedCallback sliceSelectedCallback, SliceSelectedCallback sliceRelationshipViewCallback)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
             // The find slice menu only works with a single entity selected.
             if (inputEntities.size() != 1)
             {
@@ -2244,7 +2244,7 @@ namespace AzToolsFramework
         //=========================================================================
         bool DoEntitiesHaveOverrides(const AzToolsFramework::EntityIdList& inputEntities)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             AZ::SerializeContext* serializeContext = nullptr;
             AZ::ComponentApplicationBus::BroadcastResult(serializeContext, &AZ::ComponentApplicationBus::Events::GetSerializeContext);
@@ -2287,7 +2287,7 @@ namespace AzToolsFramework
         //=========================================================================
         bool IsReparentNonTrivial(const AZ::EntityId& entityId, const AZ::EntityId& newParentId)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             AZ::EntityId oldParentId;
             AZ::TransformBus::EventResult(oldParentId, entityId, &AZ::TransformBus::Events::GetParentId);
@@ -2358,7 +2358,7 @@ namespace AzToolsFramework
 
         void ReparentNonTrivialSliceInstanceHierarchy(const AZ::EntityId& entityId, const AZ::EntityId& newParentId)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             AZ::SliceComponent::SliceInstanceEntityIdRemapList subslicesToDetach;
             AzToolsFramework::EntityIdList entitiesToDetach;
@@ -2892,7 +2892,7 @@ namespace AzToolsFramework
             //=========================================================================
             void GenerateSuggestedSliceFilenameFromEntities(const AzToolsFramework::EntityIdList& entities, AZStd::string& outName)
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+                AZ_PROFILE_FUNCTION(AzToolsFramework);
 
                 // Determine suggested save name for slice based on entity names
                 // For example, with entities Entity0, Entity1, and Entity2, we would end up with
@@ -2962,7 +2962,7 @@ namespace AzToolsFramework
             //=========================================================================
             void GenerateSuggestedSlicePath(const AZStd::string& sliceName, const AZStd::string& targetDirectory, AZStd::string& suggestedFullPath)
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+                AZ_PROFILE_FUNCTION(AzToolsFramework);
 
                 // Generate full suggested path from sliceName - if given NewSlice as sliceName,
                 // NewSlice_001.slice would be tried, and if that already existed we would suggest
@@ -3079,7 +3079,7 @@ namespace AzToolsFramework
                 QWidget* activeWindow,
                 bool defaultGenerateSharedRoot)
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+                AZ_PROFILE_FUNCTION(AzToolsFramework);
 
                 AZ::SerializeContext* serializeContext = nullptr;
                 AZ::ComponentApplicationBus::BroadcastResult(serializeContext, &AZ::ComponentApplicationBus::Events::GetSerializeContext);
@@ -3105,7 +3105,7 @@ namespace AzToolsFramework
                         {
                             int response;
                             {
-                                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "SliceUtilities::CheckAndAddSliceRoot:SingleRootUserQuery");
+                                AZ_PROFILE_SCOPE(AzToolsFramework, "SliceUtilities::CheckAndAddSliceRoot:SingleRootUserQuery");
                                 response = QMessageBox::warning(activeWindow,
                                     QStringLiteral("Cannot Create Slice"),
                                     QString("The slice cannot be created because no single transform root is defined. "
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/EditorLayerComponent.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/EditorLayerComponent.cpp
index 6b897efdf8..cca0071a4d 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/EditorLayerComponent.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/EditorLayerComponent.cpp
@@ -345,7 +345,7 @@ namespace AzToolsFramework
             EntityList& entityList,
             AZ::SliceComponent::SliceReferenceToInstancePtrs& layerInstances)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
             EditorLayer layer;
             LayerResult layerPrepareResult = PrepareLayerForSaving(layer, entityList, layerInstances);
             if (!layerPrepareResult.IsSuccess())
@@ -373,7 +373,7 @@ namespace AzToolsFramework
             AZ::SliceComponent::SliceAssetToSliceInstancePtrs& sliceInstances,
             AZStd::unordered_map<AZ::EntityId, AZ::Entity*>& uniqueEntities)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
             // If this layer is being loaded, it won't have a level save dependency yet, so clear that flag.
             m_mustSaveLevelWhenLayerSaves = false;
             QString fullPathName = levelPakFile;
@@ -518,7 +518,7 @@ namespace AzToolsFramework
             EntityList& entityList,
             AZ::SliceComponent::SliceReferenceToInstancePtrs& layerInstances)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
             // Move the editable data into the data serialized to the layer, and not the layer component.
             layer.m_layerProperties = m_editableLayerProperties;
             layer.m_layerEntityId = GetEntityId();
@@ -640,7 +640,7 @@ namespace AzToolsFramework
             const EditorLayer& layer,
             AZ::IO::ByteContainerStream<AZStd::vector<char> >& entitySaveStream)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
             m_otherLayersToSave.clear();
             m_mustSaveLevelWhenLayerSaves = false;
 
@@ -662,7 +662,7 @@ namespace AzToolsFramework
             QString levelAbsoluteFolder,
             const AZ::IO::ByteContainerStream<AZStd::vector<char> >& entitySaveStream)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
             AZStd::string layerBaseFileName(m_layerFileName);
 
             // Write to a temp file first.
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/EditorSelectionAccentSystemComponent.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/EditorSelectionAccentSystemComponent.cpp
index ff9eb025d7..56b0177e94 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/EditorSelectionAccentSystemComponent.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/EditorSelectionAccentSystemComponent.cpp
@@ -68,7 +68,7 @@ namespace AzToolsFramework
             AZStd::function<void()> accentRefreshCallback =
                 [this]()
                 {
-                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "EditorSelectionAccentSystemComponent::QueueAccentRefresh:AccentRefreshCallback");
+                    AZ_PROFILE_SCOPE(AzToolsFramework, "EditorSelectionAccentSystemComponent::QueueAccentRefresh:AccentRefreshCallback");
                     InvalidateAccents();
                     RecalculateAndApplyAccents();
                     m_isAccentRefreshQueued = false;
@@ -79,14 +79,14 @@ namespace AzToolsFramework
 
         void EditorSelectionAccentSystemComponent::ForceSelectionAccentRefresh()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
             InvalidateAccents();
             RecalculateAndApplyAccents();
         }
 
         void EditorSelectionAccentSystemComponent::InvalidateAccents()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
             for (const AZ::EntityId& accentedEntity : m_currentlyAccentedEntities)
             {
                 AzToolsFramework::ComponentEntityEditorRequestBus::Event(accentedEntity, &AzToolsFramework::ComponentEntityEditorRequests::SetSandboxObjectAccent, ComponentEntityAccentType::None);
@@ -96,7 +96,7 @@ namespace AzToolsFramework
 
         void EditorSelectionAccentSystemComponent::RecalculateAndApplyAccents()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
             AzToolsFramework::EntityIdList selectedEntities;
             AzToolsFramework::ToolsApplicationRequests::Bus::BroadcastResult(selectedEntities, &AzToolsFramework::ToolsApplicationRequests::GetSelectedEntities);
             AzToolsFramework::EntityIdSet selectedEntitiesSet;
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/ComponentPalette/ComponentPaletteUtil.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/ComponentPalette/ComponentPaletteUtil.cpp
index 3ccb4065bf..6f3727bdb4 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/ComponentPalette/ComponentPaletteUtil.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/ComponentPalette/ComponentPaletteUtil.cpp
@@ -121,7 +121,7 @@ namespace AzToolsFramework
             ComponentDataTable &componentDataTable,
             ComponentIconTable &componentIconTable)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
             serializeContext->EnumerateDerived<AZ::Component>(
                 [&](const AZ::SerializeContext::ClassData* componentClass, const AZ::Uuid& knownType) -> bool
                 {
@@ -179,7 +179,7 @@ namespace AzToolsFramework
             const AZStd::vector<AZ::ComponentServiceType>& incompatibleServiceFilter
         )
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
             
             bool containsEditable = false;
 
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/ComponentPalette/ComponentPaletteWidget.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/ComponentPalette/ComponentPaletteWidget.cpp
index afa7edc565..67598f9fca 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/ComponentPalette/ComponentPaletteWidget.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/ComponentPalette/ComponentPaletteWidget.cpp
@@ -130,7 +130,7 @@ namespace AzToolsFramework
 
     void ComponentPaletteWidget::UpdateContent()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         m_componentModel->clear();
 
         bool applyRegExFilter = !m_searchRegExp.isEmpty();
@@ -321,7 +321,7 @@ namespace AzToolsFramework
 
     void ComponentPaletteWidget::UpdateSearch()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         m_searchRegExp = QRegExp(m_searchText->text(), Qt::CaseInsensitive, QRegExp::RegExp);
         m_searchText->setFocus();
         UpdateContent();
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/Outliner/EntityOutlinerListModel.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/Outliner/EntityOutlinerListModel.cpp
index 4115fe409e..806170df6f 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/Outliner/EntityOutlinerListModel.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/Outliner/EntityOutlinerListModel.cpp
@@ -936,7 +936,7 @@ namespace AzToolsFramework
 
     bool EntityOutlinerListModel::CanReparentEntities(const AZ::EntityId& newParentId, const EntityIdList &selectedEntityIds) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         if (selectedEntityIds.empty())
         {
             return false;
@@ -1025,7 +1025,7 @@ namespace AzToolsFramework
 
     bool EntityOutlinerListModel::ReparentEntities(const AZ::EntityId& newParentId, const EntityIdList &selectedEntityIds, const AZ::EntityId& beforeEntityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         if (!CanReparentEntities(newParentId, selectedEntityIds))
         {
             return false;
@@ -1105,7 +1105,7 @@ namespace AzToolsFramework
 
     QMimeData* EntityOutlinerListModel::mimeData(const QModelIndexList& indexes) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         AZ::TypeId uuid1 = AZ::AzTypeInfo<AZ::Entity>::Uuid();
         AZ::TypeId uuid2 = AZ::AzTypeInfo<EditorEntityIdContainer>::Uuid();
 
@@ -1195,7 +1195,7 @@ namespace AzToolsFramework
 
     void EntityOutlinerListModel::ProcessEntityUpdates()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+        AZ_PROFILE_FUNCTION(Editor);
         m_entityChangeQueued = false;
         if (m_layoutResetQueued)
         {
@@ -1203,7 +1203,7 @@ namespace AzToolsFramework
         }
 
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Editor, "EntityOutlinerListModel::ProcessEntityUpdates:ExpandQueue");
+            AZ_PROFILE_SCOPE(Editor, "EntityOutlinerListModel::ProcessEntityUpdates:ExpandQueue");
             for (auto entityId : m_entityExpandQueue)
             {
                 emit ExpandEntity(entityId, IsExpanded(entityId));
@@ -1212,7 +1212,7 @@ namespace AzToolsFramework
         }
 
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Editor, "EntityOutlinerListModel::ProcessEntityUpdates:SelectQueue");
+            AZ_PROFILE_SCOPE(Editor, "EntityOutlinerListModel::ProcessEntityUpdates:SelectQueue");
             for (auto entityId : m_entitySelectQueue)
             {
                 emit SelectEntity(entityId, IsSelected(entityId));
@@ -1222,7 +1222,7 @@ namespace AzToolsFramework
 
         if (!m_entityChangeQueue.empty())
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Editor, "EntityOutlinerListModel::ProcessEntityUpdates:ChangeQueue");
+            AZ_PROFILE_SCOPE(Editor, "EntityOutlinerListModel::ProcessEntityUpdates:ChangeQueue");
 
             // its faster to just do a bulk data change than to carefully pick out indices
             // so we'll just merge all ranges into a single range rather than try to make gaps
@@ -1255,7 +1255,7 @@ namespace AzToolsFramework
         }
 
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Editor, "EntityOutlinerListModel::ProcessEntityUpdates:LayoutChanged");
+            AZ_PROFILE_SCOPE(Editor, "EntityOutlinerListModel::ProcessEntityUpdates:LayoutChanged");
             if (m_entityLayoutQueued)
             {
                 emit layoutAboutToBeChanged();
@@ -1265,7 +1265,7 @@ namespace AzToolsFramework
         }
 
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Editor, "EntityOutlinerListModel::ProcessEntityUpdates:InvalidateFilter");
+            AZ_PROFILE_SCOPE(Editor, "EntityOutlinerListModel::ProcessEntityUpdates:InvalidateFilter");
             if (m_isFilterDirty)
             {
                 InvalidateFilter();
@@ -1288,7 +1288,7 @@ namespace AzToolsFramework
 
     void EntityOutlinerListModel::ProcessEntityInfoResetEnd()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         m_layoutResetQueued = false;
         m_entityChangeQueued = false;
         m_entityChangeQueue.clear();
@@ -1309,7 +1309,7 @@ namespace AzToolsFramework
     void EntityOutlinerListModel::OnEntityInfoUpdatedAddChildEnd(AZ::EntityId parentId, AZ::EntityId childId)
     {
         (void)parentId;
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         endInsertRows();
 
         //expand ancestors if a new descendant is already selected
@@ -1347,7 +1347,7 @@ namespace AzToolsFramework
     void EntityOutlinerListModel::OnEntityInfoUpdatedRemoveChildEnd(AZ::EntityId parentId, AZ::EntityId childId)
     {
         (void)childId;
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         endResetModel();
 
@@ -1366,7 +1366,7 @@ namespace AzToolsFramework
 
     void EntityOutlinerListModel::OnEntityInfoUpdatedOrderEnd(AZ::EntityId parentId, AZ::EntityId childId, AZ::u64 index)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+        AZ_PROFILE_FUNCTION(Editor);
         (void)index;
         m_entityLayoutQueued = true;
         QueueEntityUpdate(parentId);
@@ -1425,7 +1425,7 @@ namespace AzToolsFramework
 
     QModelIndex EntityOutlinerListModel::GetIndexFromEntity(const AZ::EntityId& entityId, int column) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (entityId.IsValid())
         {
@@ -1587,7 +1587,7 @@ namespace AzToolsFramework
 
     void EntityOutlinerListModel::ExpandAncestors(const AZ::EntityId& entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         //typically to reveal selected entities, expand all parent entities
         if (entityId.IsValid())
         {
@@ -1792,7 +1792,7 @@ namespace AzToolsFramework
 
     bool EntityOutlinerListModel::AreAllDescendantsSameLockState(const AZ::EntityId& entityId) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         //TODO result can be cached in mutable map and cleared when any descendant changes to avoid recursion in deep hierarchies
         bool isLocked = false;
         EditorEntityInfoRequestBus::EventResult(isLocked, entityId, &EditorEntityInfoRequestBus::Events::IsJustThisEntityLocked);
@@ -1813,7 +1813,7 @@ namespace AzToolsFramework
 
     bool EntityOutlinerListModel::AreAllDescendantsSameVisibleState(const AZ::EntityId& entityId) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         //TODO result can be cached in mutable map and cleared when any descendant changes to avoid recursion in deep hierarchies
 
         bool isVisible = IsEntitySetToBeVisible(entityId);
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/Outliner/EntityOutlinerWidget.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/Outliner/EntityOutlinerWidget.cpp
index c6d3c2f28f..4db235d073 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/Outliner/EntityOutlinerWidget.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/Outliner/EntityOutlinerWidget.cpp
@@ -98,7 +98,7 @@ namespace
 
     void SortEntityChildren(AZ::EntityId entityId, const EntityIdCompareFunc& comparer, AzToolsFramework::EntityOrderArray* newEntityOrder = nullptr)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AzToolsFramework::EntityOrderArray entityOrderArray = AzToolsFramework::GetEntityChildOrder(entityId);
         AZStd::sort(entityOrderArray.begin(), entityOrderArray.end(), comparer);
@@ -112,7 +112,7 @@ namespace
 
     void SortEntityChildrenRecursively(AZ::EntityId entityId, const EntityIdCompareFunc& comparer)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AzToolsFramework::EntityOrderArray entityOrderArray;
         SortEntityChildren(entityId, comparer, &entityOrderArray);
@@ -325,7 +325,7 @@ namespace AzToolsFramework
             return;
         }
 
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         EntityIdList newlySelected;
         ExtractEntityIdsFromSelection(selected, newlySelected);
@@ -472,7 +472,7 @@ namespace AzToolsFramework
     {
         if (m_selectionChangeQueued)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             m_selectionChangeInProgress = true;
 
@@ -480,7 +480,7 @@ namespace AzToolsFramework
             {
                 // Calling Deselect for a large number of items is very slow,
                 // use a single ClearAndSelect call instead.
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "EntityOutlinerWidget::ModelEntitySelectionChanged:ClearAndSelect");
+                AZ_PROFILE_SCOPE(AzToolsFramework, "EntityOutlinerWidget::ModelEntitySelectionChanged:ClearAndSelect");
 
                 EntityIdList selectedEntities;
                 ToolsApplicationRequests::Bus::BroadcastResult(selectedEntities, &ToolsApplicationRequests::Bus::Events::GetSelectedEntities);
@@ -491,12 +491,12 @@ namespace AzToolsFramework
             else
             {
                 {
-                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "EntityOutlinerWidget::ModelEntitySelectionChanged:Deselect");
+                    AZ_PROFILE_SCOPE(AzToolsFramework, "EntityOutlinerWidget::ModelEntitySelectionChanged:Deselect");
                     m_gui->m_objectTree->selectionModel()->select(
                         BuildSelectionFromEntities(m_entitiesToDeselect), QItemSelectionModel::Deselect);
                 }
                 {
-                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "EntityOutlinerWidget::ModelEntitySelectionChanged:Select");
+                    AZ_PROFILE_SCOPE(AzToolsFramework, "EntityOutlinerWidget::ModelEntitySelectionChanged:Select");
                     m_gui->m_objectTree->selectionModel()->select(
                         BuildSelectionFromEntities(m_entitiesToSelect), QItemSelectionModel::Select);
                 }
@@ -519,7 +519,7 @@ namespace AzToolsFramework
     template <class EntityIdCollection>
     QItemSelection EntityOutlinerWidget::BuildSelectionFromEntities(const EntityIdCollection& entityIds)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         QItemSelection selection;
 
         for (const auto& entityId : entityIds)
@@ -539,7 +539,7 @@ namespace AzToolsFramework
 
     void EntityOutlinerWidget::OnOpenTreeContextMenu(const QPoint& pos)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+        AZ_PROFILE_FUNCTION(Editor);
 
         bool isDocumentOpen = false;
         EBUS_EVENT_RESULT(isDocumentOpen, EditorRequests::Bus, IsLevelDocumentOpen);
@@ -1057,7 +1057,7 @@ namespace AzToolsFramework
 
     void EntityOutlinerWidget::OnSearchTextChanged(const QString& activeTextFilter)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         AZStd::string filterString = activeTextFilter.toUtf8().data();
 
         m_listModel->SearchStringChanged(filterString);
@@ -1168,7 +1168,7 @@ namespace AzToolsFramework
 
     void EntityOutlinerWidget::SortContent()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         m_sortContentQueued = false;
 
@@ -1204,7 +1204,7 @@ namespace AzToolsFramework
 
         if (sortMode != EntityOutliner::DisplaySortMode::Manually)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
             auto comparer = AZStd::bind(&CompareEntitiesForSorting, AZStd::placeholders::_1, AZStd::placeholders::_2, sortMode);
             SortEntityChildrenRecursively(AZ::EntityId(), comparer);
         }
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/Prefab/PrefabIntegrationManager.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/Prefab/PrefabIntegrationManager.cpp
index 9f75abb32a..c17b96411e 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/Prefab/PrefabIntegrationManager.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/Prefab/PrefabIntegrationManager.cpp
@@ -434,7 +434,7 @@ namespace AzToolsFramework
 
         void PrefabIntegrationManager::GenerateSuggestedFilenameFromEntities(const EntityIdList& entityIds, AZStd::string& outName)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             AZStd::string suggestedName;
 
@@ -515,7 +515,7 @@ namespace AzToolsFramework
             while (true)
             {
                 {
-                    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+                    AZ_PROFILE_FUNCTION(AzToolsFramework);
                     saveAs = QFileDialog::getSaveFileName(nullptr, QString("Save As..."), saveAsInitialSuggestedFullPath.c_str(), QString("Prefabs (*.prefab)"));
                 }
 
@@ -851,7 +851,7 @@ namespace AzToolsFramework
 
         void PrefabIntegrationManager::GatherAllReferencedEntities(EntityIdSet& entitiesWithReferences, AZ::SerializeContext& serializeContext)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             AZStd::vector<AZ::EntityId> floodQueue;
             floodQueue.reserve(entitiesWithReferences.size());
@@ -943,7 +943,7 @@ namespace AzToolsFramework
         bool PrefabIntegrationManager::QueryAndPruneMissingExternalReferences(EntityIdSet& entities, EntityIdSet& selectedAndReferencedEntities,
             bool& useReferencedEntities, bool defaultMoveExternalRefs)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
             useReferencedEntities = false;
 
             AZStd::string includedEntities;
@@ -978,7 +978,7 @@ namespace AzToolsFramework
             {
                 if (!defaultMoveExternalRefs)
                 {
-                    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+                    AZ_PROFILE_FUNCTION(AzToolsFramework);
 
                     const AZStd::string message = AZStd::string::format(
                         "Entity references may not be valid if the entity IDs change or if the entities do not exist when the prefab is instantiated.\r\n\r\nSelected Entities\n%s\nReferenced Entities\n%s\n",
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/ComponentEditor.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/ComponentEditor.cpp
index 5fa8e9adbe..fbbf55d0ad 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/ComponentEditor.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/ComponentEditor.cpp
@@ -527,7 +527,7 @@ namespace AzToolsFramework
 
     void ComponentEditor::SetComponentOverridden(const bool overridden)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const auto entityId = m_components[0]->GetEntityId();
         AZ::SliceComponent::SliceInstanceAddress sliceInstanceAddress;
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/EntityPropertyEditor.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/EntityPropertyEditor.cpp
index 2c46bb2d26..ec09275703 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/EntityPropertyEditor.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/EntityPropertyEditor.cpp
@@ -699,7 +699,7 @@ namespace AzToolsFramework
 
     void EntityPropertyEditor::BeforeEntitySelectionChanged()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         if (IsLockedToSpecificEntities())
         {
             return;
@@ -723,7 +723,7 @@ namespace AzToolsFramework
         const AzToolsFramework::EntityIdList& newlySelectedEntities,
         const AzToolsFramework::EntityIdList& newlyDeselectedEntities)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         if (IsLockedToSpecificEntities())
         {
             // ensure we refresh all entity property editors when
@@ -951,7 +951,7 @@ namespace AzToolsFramework
 
     EntityPropertyEditor::SelectionEntityTypeInfo EntityPropertyEditor::GetSelectionEntityTypeInfo(const EntityIdList& selection) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         SelectionEntityTypeInfo result = SelectionEntityTypeInfo::None;
 
         InspectorLayout layout = GetCurrentInspectorLayout();
@@ -1069,7 +1069,7 @@ namespace AzToolsFramework
 
     void EntityPropertyEditor::UpdateContents()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         setUpdatesEnabled(false);
 
         m_isBuildingProperties = true;
@@ -1921,7 +1921,7 @@ namespace AzToolsFramework
 
     void EntityPropertyEditor::QueuePropertyRefresh()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         if (!m_isAlreadyQueuedRefresh)
         {
             m_isAlreadyQueuedRefresh = true;
@@ -3234,7 +3234,7 @@ namespace AzToolsFramework
 
     void EntityPropertyEditor::UpdateActions()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (m_disabled)
         {
@@ -3282,7 +3282,7 @@ namespace AzToolsFramework
         // Even though this causes two loops on the selected entity list, calling GetSelectionEntityTypeInfo avoids duplicating code.
         SelectionEntityTypeInfo selectionTypeInfo;
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "EntityPropertyEditor::UpdateActions GetSelectionEntityTypeInfo");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "EntityPropertyEditor::UpdateActions GetSelectionEntityTypeInfo");
             selectionTypeInfo = GetSelectionEntityTypeInfo(m_selectedEntityIds);
         }
         m_actionToAddComponents->setEnabled(CanAddComponentsToSelection(selectionTypeInfo));
@@ -3907,7 +3907,7 @@ namespace AzToolsFramework
 
     void EntityPropertyEditor::ClearComponentEditorDragging()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         for (auto componentEditor : m_componentEditors)
         {
             componentEditor->SetDragged(false);
@@ -3918,7 +3918,7 @@ namespace AzToolsFramework
 
     void EntityPropertyEditor::ClearComponentEditorSelection()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         for (auto componentEditor : m_componentEditors)
         {
             componentEditor->SetSelected(false);
@@ -4043,7 +4043,7 @@ namespace AzToolsFramework
 
     void EntityPropertyEditor::UpdateSelectionCache()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         m_selectedComponentEditors.clear();
         m_selectedComponentEditors.reserve(m_componentEditors.size());
         for (auto componentEditor : m_componentEditors)
@@ -4070,7 +4070,7 @@ namespace AzToolsFramework
 
     void EntityPropertyEditor::SaveComponentEditorState()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // SaveComponentEditorState can be called when adding or removing a
         // component, the components list stored by the component editor
@@ -5584,14 +5584,14 @@ namespace AzToolsFramework
 
     void EntityPropertyEditor::ConnectToEntityBuses(const AZ::EntityId& entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         AzToolsFramework::EditorInspectorComponentNotificationBus::MultiHandler::BusConnect(entityId);
         AzToolsFramework::PropertyEditorEntityChangeNotificationBus::MultiHandler::BusConnect(entityId);
     }
 
     void EntityPropertyEditor::DisconnectFromEntityBuses(const AZ::EntityId& entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         AzToolsFramework::EditorInspectorComponentNotificationBus::MultiHandler::BusDisconnect(entityId);
         AzToolsFramework::PropertyEditorEntityChangeNotificationBus::MultiHandler::BusDisconnect(entityId);
     }
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/InstanceDataHierarchy.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/InstanceDataHierarchy.cpp
index 2e697a7398..fccabbf205 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/InstanceDataHierarchy.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/InstanceDataHierarchy.cpp
@@ -603,7 +603,7 @@ namespace AzToolsFramework
     //-----------------------------------------------------------------------------
     void InstanceDataHierarchy::Build(AZ::SerializeContext* sc, unsigned int accessFlags, DynamicEditDataProvider dynamicEditDataProvider, ComponentEditor* editorParent)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AZ_Assert(sc, "sc can't be NULL!");
         AZ_Assert(m_rootInstances.size() > 0, "No root instances have been added to this hierarchy!");
@@ -761,7 +761,7 @@ namespace AzToolsFramework
     //-----------------------------------------------------------------------------
     void InstanceDataHierarchy::FixupEditData(InstanceDataNode* node, int siblingIdx)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         bool mergeElementEditData = node->m_classElement && node->m_classElement->m_editData && node->GetElementEditMetadata() != node->m_classElement->m_editData;
         bool mergeContainerEditData = node->m_parent && node->m_parent->m_classData->m_container && node->m_parent->GetElementEditMetadata() && (node->m_classElement->m_flags & AZ::SerializeContext::ClassElement::FLG_POINTER) == 0;
@@ -915,7 +915,7 @@ namespace AzToolsFramework
     //-----------------------------------------------------------------------------
     bool InstanceDataHierarchy::BeginNode(void* ptr, const AZ::SerializeContext::ClassData* classData, const AZ::SerializeContext::ClassElement* classElement, DynamicEditDataProvider dynamicEditDataProvider)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const AZ::Edit::ElementData* elementEditData = nullptr;
 
@@ -1140,7 +1140,7 @@ namespace AzToolsFramework
     //-----------------------------------------------------------------------------
     bool InstanceDataHierarchy::EndNode()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AZ_Assert(m_curParentNode, "EndEnum called without a matching BeginNode call!");
 
@@ -1177,7 +1177,7 @@ namespace AzToolsFramework
     //-----------------------------------------------------------------------------
     bool InstanceDataHierarchy::RefreshComparisonData(unsigned int accessFlags, DynamicEditDataProvider dynamicEditDataProvider)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (!m_root || m_comparisonInstances.empty())
         {
@@ -1438,7 +1438,7 @@ namespace AzToolsFramework
         RemovedNodeCB removedNodeCallback,
         ChangedNodeCB changedNodeCallback)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         targetNode->m_comparisonNode = sourceNode;
 
@@ -1582,7 +1582,7 @@ namespace AzToolsFramework
             ContainerChildNodeBeingCreatedCB containerChildNodeBeingCreatedCB,
             const InstanceDataNode::Address& filterElementAddress)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (!context)
         {
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyEditorAPI.h b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyEditorAPI.h
index 3c72e8bc9c..415a87f984 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyEditorAPI.h
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyEditorAPI.h
@@ -161,7 +161,7 @@ namespace AzToolsFramework
 
         virtual void ReadValuesIntoGUI_Internal(QWidget* widget, InstanceDataNode* node) override
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             for (size_t i = 0; i < node->GetNumInstances(); ++i)
             {
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyEditorAPI_Internals.h b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyEditorAPI_Internals.h
index 15506c1a50..8b53121776 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyEditorAPI_Internals.h
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyEditorAPI_Internals.h
@@ -15,6 +15,7 @@
 // A user is expected to derive from PropertyHandler<PropertyType, WidgetType>
 // and implement that interface, then register it with the property manager.
 
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/RTTI/AttributeReader.h>
 #include <AzCore/Serialization/EditContext.h>
 #include <AzToolsFramework/UI/PropertyEditor/InstanceDataHierarchy.h>
@@ -257,7 +258,7 @@ namespace AzToolsFramework
 
         virtual void ReadValuesIntoGUI_Internal(QWidget* widget, InstanceDataNode* node) override
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             WidgetType* wid = static_cast<WidgetType*>(widget);
 
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyEditorApi.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyEditorApi.cpp
index 8693ca2d48..096fb6c7c1 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyEditorApi.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyEditorApi.cpp
@@ -98,7 +98,7 @@ namespace AzToolsFramework
     //-----------------------------------------------------------------------------
     NodeDisplayVisibility CalculateNodeDisplayVisibility(const InstanceDataNode& node, bool isSlicePushUI)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         NodeDisplayVisibility visibility = NodeDisplayVisibility::NotVisible;
 
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyRowWidget.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyRowWidget.cpp
index 604c6141d7..44e71daf71 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyRowWidget.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyRowWidget.cpp
@@ -458,7 +458,7 @@ namespace AzToolsFramework
 
     void PropertyRowWidget::OnValuesUpdated()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (m_sourceNode)
         {
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/ReflectedPropertyEditor.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/ReflectedPropertyEditor.cpp
index 5d5b00e83d..87df1eff1b 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/ReflectedPropertyEditor.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/ReflectedPropertyEditor.cpp
@@ -1038,12 +1038,12 @@ namespace AzToolsFramework
 
     void ReflectedPropertyEditor::InvalidateValues()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         m_releasePrompt = true;
 
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "ReflectedPropertyEditor::InvalidateValues:InstancesRefreshDataCompare");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "ReflectedPropertyEditor::InvalidateValues:InstancesRefreshDataCompare");
             for (InstanceDataHierarchy& instance : m_impl->m_instances)
             {
                 const bool dataIdentical = instance.RefreshComparisonData(
@@ -1057,7 +1057,7 @@ namespace AzToolsFramework
         }
 
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "ReflectedPropertyEditor::InvalidateValues:RowWidgetGuiUpdate");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "ReflectedPropertyEditor::InvalidateValues:RowWidgetGuiUpdate");
             for (auto it = m_impl->m_userWidgetsToData.begin(); it != m_impl->m_userWidgetsToData.end(); ++it)
             {
                 auto rowWidget = m_impl->m_widgets.find(it->second);
@@ -2294,7 +2294,7 @@ namespace AzToolsFramework
 
     void ReflectedPropertyEditor::DoRefresh()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (m_impl->m_preventRefresh || (m_impl->m_queuedRefreshLevel == Refresh_None))
         {
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Viewport/EditorContextMenu.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Viewport/EditorContextMenu.cpp
index b2c378181e..ff13bce531 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Viewport/EditorContextMenu.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Viewport/EditorContextMenu.cpp
@@ -23,7 +23,7 @@ namespace AzToolsFramework
 {
     void EditorContextMenuUpdate(EditorContextMenu& contextMenu, const ViewportInteraction::MouseInteractionEvent& mouseInteraction)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // could potentially show the context menu
         if (mouseInteraction.m_mouseInteraction.m_mouseButtons.Right() &&
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorBoxSelect.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorBoxSelect.cpp
index d4d53c5907..c39b2c0ebc 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorBoxSelect.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorBoxSelect.cpp
@@ -22,7 +22,7 @@ namespace AzToolsFramework
     void EditorBoxSelect::HandleMouseInteraction(
         const ViewportInteraction::MouseInteractionEvent& mouseInteraction)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         m_cursorState.SetCurrentPosition(mouseInteraction.m_mouseInteraction.m_mousePick.m_screenCoordinates);
 
@@ -74,7 +74,7 @@ namespace AzToolsFramework
 
     void EditorBoxSelect::Display2d(const AzFramework::ViewportInfo& viewportInfo, AzFramework::DebugDisplayRequests& debugDisplay)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         m_cursorState.Update();
 
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorHelpers.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorHelpers.cpp
index 304a4df31f..7abff230e3 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorHelpers.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorHelpers.cpp
@@ -64,7 +64,7 @@ namespace AzToolsFramework
     // note: this is mostly likely distance from the camera
     static float GetIconScale(const float distSq)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         return s_iconMinScale +
             (s_iconMaxScale - s_iconMinScale) *
@@ -74,7 +74,7 @@ namespace AzToolsFramework
     static void DisplayComponents(
         const AZ::EntityId entityId, const AzFramework::ViewportInfo& viewportInfo, AzFramework::DebugDisplayRequests& debugDisplay)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const AZ::Entity* entity = AZ::Interface<AZ::ComponentApplicationRequests>::Get()->FindEntity(entityId);
         AzFramework::EntityDebugDisplayEventBus::Event(
@@ -114,7 +114,7 @@ namespace AzToolsFramework
     AZ::EntityId EditorHelpers::HandleMouseInteraction(
         const AzFramework::CameraState& cameraState, const ViewportInteraction::MouseInteractionEvent& mouseInteraction)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const int viewportId = mouseInteraction.m_mouseInteraction.m_interactionId.m_viewportId;
 
@@ -185,7 +185,7 @@ namespace AzToolsFramework
         AzFramework::DebugDisplayRequests& debugDisplay,
         const AZStd::function<bool(AZ::EntityId)>& showIconCheck)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (HelpersVisible())
         {
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemComponent.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemComponent.cpp
index 696cf6b184..7002436d13 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemComponent.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorInteractionSystemComponent.cpp
@@ -85,7 +85,7 @@ namespace AzToolsFramework
     void EditorInteractionSystemComponent::DisplayViewport(
         const AzFramework::ViewportInfo& viewportInfo, AzFramework::DebugDisplayRequests& debugDisplay)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // calculate which entities are in the view and can be interacted with
         // and cache that data to make iterating/looking it up much faster
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.cpp
index 7cd0170989..ea1bc73056 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.cpp
@@ -37,7 +37,7 @@ namespace AzToolsFramework
     static void HandleAccents(
         const AZ::EntityId entityIdUnderCursor, AZ::EntityId& hoveredEntityId, const ViewportInteraction::MouseButtons mouseButtons)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const bool invalidMouseButtonHeld = mouseButtons.Middle() || mouseButtons.Right();
 
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorSelectionUtil.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorSelectionUtil.cpp
index 8e08dc9d97..7cb0e718a8 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorSelectionUtil.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorSelectionUtil.cpp
@@ -50,7 +50,7 @@ namespace AzToolsFramework
 
     AzFramework::ScreenPoint GetScreenPosition(const int viewportId, const AZ::Vector3& worldTranslation)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         auto screenPosition = AzFramework::ScreenPoint(0, 0);
         ViewportInteraction::ViewportInteractionRequestBus::EventResult(
@@ -62,7 +62,7 @@ namespace AzToolsFramework
 
     bool AabbIntersectMouseRay(const ViewportInteraction::MouseInteraction& mouseInteraction, const AZ::Aabb& aabb)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const AZ::Vector3 rayScaledDir = mouseInteraction.m_mousePick.m_rayDirection * s_pickRayLength;
 
@@ -78,7 +78,7 @@ namespace AzToolsFramework
         float& closestDistance,
         const int viewportId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         bool entityPicked = false;
         EditorComponentSelectionRequestsBus::EnumerateHandlersId(
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.cpp
index b05dfd0676..d315243697 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.cpp
@@ -276,7 +276,7 @@ namespace AzToolsFramework
 
     static void DestroyManipulators(EntityIdManipulators& manipulators)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (manipulators.m_manipulators)
         {
@@ -306,7 +306,7 @@ namespace AzToolsFramework
     {
         static_assert(AZStd::is_same<typename EntityIdContainer::value_type, AZ::EntityId>::value, "Container type is not an EntityId");
 
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         return AZStd::vector<AZ::EntityId>(entityIdContainer.begin(), entityIdContainer.end());
     }
 
@@ -316,7 +316,7 @@ namespace AzToolsFramework
     {
         static_assert(AZStd::is_same<typename EntityIdMap::key_type, AZ::EntityId>::value, "Container key type is not an EntityId");
 
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AZStd::vector<AZ::EntityId> entityIds;
         entityIds.reserve(entityIdMap.size());
@@ -348,7 +348,7 @@ namespace AzToolsFramework
         EntitySelectFuncType selectFunc2,
         Compare outgoingCheck)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (boxSelect->contains(ViewportInteraction::QPointFromScreenPoint(screenPosition)))
         {
@@ -385,7 +385,7 @@ namespace AzToolsFramework
         const ViewportInteraction::KeyboardModifiers currentKeyboardModifiers,
         const ViewportInteraction::KeyboardModifiers& previousKeyboardModifiers)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (boxSelect)
         {
@@ -449,7 +449,7 @@ namespace AzToolsFramework
 
     static void InitializeTranslationLookup(EntityIdManipulators& entityIdManipulators)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         for (auto& entityIdLookup : entityIdManipulators.m_lookups)
         {
@@ -498,7 +498,7 @@ namespace AzToolsFramework
     // return either center or entity pivot
     static AZ::Vector3 CalculatePivotTranslation(const AZ::EntityId entityId, const EditorTransformComponentSelectionRequests::Pivot pivot)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AZ::Transform worldFromLocal = AZ::Transform::CreateIdentity();
         AZ::TransformBus::EventResult(worldFromLocal, entityId, &AZ::TransformBus::Events::GetWorldTM);
@@ -539,7 +539,7 @@ namespace AzToolsFramework
     {
         PivotOrientationResult CalculatePivotOrientation(const AZ::EntityId entityId, const ReferenceFrame referenceFrame)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // initialize to world space, no parent
             PivotOrientationResult result{ AZ::Quaternion::CreateIdentity(), AZ::EntityId() };
@@ -577,7 +577,7 @@ namespace AzToolsFramework
     template<typename EntityIdMapIterator>
     static ETCS::PivotOrientationResult CalculateParentSpace(EntityIdMapIterator begin, EntityIdMapIterator end)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // initialize to world with no parent
         ETCS::PivotOrientationResult result{ AZ::Quaternion::CreateIdentity(), AZ::EntityId() };
@@ -629,7 +629,7 @@ namespace AzToolsFramework
     {
         static_assert(AZStd::is_same<typename EntityIdMap::key_type, AZ::EntityId>::value, "Container key type is not an EntityId");
 
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (!entityIdMap.empty())
         {
@@ -656,7 +656,7 @@ namespace AzToolsFramework
         {
             static_assert(AZStd::is_same<typename EntityIdMap::key_type, AZ::EntityId>::value, "Container key type is not an EntityId");
 
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // simple case with one entity
             if (entityIdMap.size() == 1)
@@ -689,7 +689,7 @@ namespace AzToolsFramework
                 AZStd::is_same<typename EntityIdMap::mapped_type, EntityIdManipulatorLookup>::value,
                 "Container value type is not an EntityIdManipulators::Lookup");
 
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // start - calculate orientation without considering current overrides/modifications
             PivotOrientationResult pivot = CalculatePivotOrientationForEntityIds(entityIdMap, referenceFrame);
@@ -747,7 +747,7 @@ namespace AzToolsFramework
         const OptionalFrame& pivotOverrideFrame,
         const EditorTransformComponentSelectionRequests::Pivot pivot)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         return pivotOverrideFrame.m_translationOverride.value_or(CalculatePivotTranslationForEntityIds(entityIdMap, pivot));
     }
@@ -756,7 +756,7 @@ namespace AzToolsFramework
     static AZ::Quaternion RecalculateAverageManipulatorOrientation(
         const EntityIdMap& entityIdMap, const OptionalFrame& pivotOverrideFrame, const ReferenceFrame referenceFrame)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         return ETCS::CalculateSelectionPivotOrientation(entityIdMap, pivotOverrideFrame, referenceFrame).m_worldOrientation;
     }
@@ -768,7 +768,7 @@ namespace AzToolsFramework
         const EditorTransformComponentSelectionRequests::Pivot pivot,
         const ReferenceFrame referenceFrame)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // return final transform, if we have an override for translation use that, otherwise
         // use centered translation of selection
@@ -825,7 +825,7 @@ namespace AzToolsFramework
         bool& transformChangedInternally,
         const AZStd::optional<ReferenceFrame> spaceLock)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         entityIdManipulators.m_manipulators->SetLocalPosition(action.LocalPosition());
 
@@ -914,7 +914,7 @@ namespace AzToolsFramework
         const ViewportInteraction::MouseButtons mouseButtons,
         const bool usingBoxSelect)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const bool invalidMouseButtonHeld = mouseButtons.Middle() || mouseButtons.Right();
 
@@ -942,7 +942,7 @@ namespace AzToolsFramework
 
     static AZ::Vector3 PickTerrainPosition(const ViewportInteraction::MouseInteraction& mouseInteraction)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const int viewportId = mouseInteraction.m_interactionId.m_viewportId;
         // get unsnapped terrain position (world space)
@@ -964,14 +964,14 @@ namespace AzToolsFramework
     template<typename EntityIdContainer>
     static bool IsEntitySelectedInternal(AZ::EntityId entityId, const EntityIdContainer& selectedEntityIds)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         const auto entityIdIt = selectedEntityIds.find(entityId);
         return entityIdIt != selectedEntityIds.end();
     }
 
     static EntityIdTransformMap RecordTransformsBefore(const EntityIdList& entityIds)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // save initial transforms - this is necessary in cases where entities exist
         // in a hierarchy. We want to make sure a parent transform does not affect
@@ -1202,7 +1202,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::BeginRecordManipulatorCommand()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // we must have an existing parent undo batch active when beginning to record
         // a manipulator command
@@ -1219,7 +1219,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::EndRecordManipulatorCommand()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (m_manipulatorMoveCommand)
         {
@@ -1245,7 +1245,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::CreateTranslationManipulators()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AZStd::unique_ptr<TranslationManipulators> translationManipulators = AZStd::make_unique<TranslationManipulators>(
             TranslationManipulators::Dimensions::Three, AZ::Transform::CreateIdentity(), AZ::Vector3::CreateOne());
@@ -1372,7 +1372,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::CreateRotationManipulators()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AZStd::unique_ptr<RotationManipulators> rotationManipulators =
             AZStd::make_unique<RotationManipulators>(AZ::Transform::CreateIdentity());
@@ -1542,7 +1542,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::CreateScaleManipulators()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AZStd::unique_ptr<ScaleManipulators> scaleManipulators = AZStd::make_unique<ScaleManipulators>(AZ::Transform::CreateIdentity());
 
@@ -1680,7 +1680,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::DeselectEntities()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (!UndoRedoOperationInProgress())
         {
@@ -1708,7 +1708,7 @@ namespace AzToolsFramework
 
     bool EditorTransformComponentSelection::SelectDeselect(const AZ::EntityId entityIdUnderCursor)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (entityIdUnderCursor.IsValid())
         {
@@ -1760,7 +1760,7 @@ namespace AzToolsFramework
 
     bool EditorTransformComponentSelection::HandleMouseInteraction(const ViewportInteraction::MouseInteractionEvent& mouseInteraction)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         CheckDirtyEntityIds();
 
@@ -2024,7 +2024,7 @@ namespace AzToolsFramework
         const QString& statusTip,
         const T& callback)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         actions.emplace_back(AZStd::make_unique<QAction>(nullptr));
 
@@ -2080,11 +2080,11 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::RegisterActions()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const auto lockUnlock = [this](const bool lock)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             ScopedUndoBatch undoBatch(s_lockSelectionUndoRedoDesc);
 
@@ -2122,7 +2122,7 @@ namespace AzToolsFramework
 
         const auto showHide = [this](const bool show)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             ScopedUndoBatch undoBatch(s_hideSelectionUndoRedoDesc);
 
@@ -2163,7 +2163,7 @@ namespace AzToolsFramework
             m_actions, { QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_L) }, UnlockAll, s_unlockAllTitle, s_unlockAllDesc,
             []()
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+                AZ_PROFILE_FUNCTION(AzToolsFramework);
 
                 ScopedUndoBatch undoBatch(s_unlockAllUndoRedoDesc);
 
@@ -2180,7 +2180,7 @@ namespace AzToolsFramework
             m_actions, { QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_H) }, ShowAll, s_showAllTitle, s_showAllDesc,
             []()
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+                AZ_PROFILE_FUNCTION(AzToolsFramework);
 
                 ScopedUndoBatch undoBatch(s_showAllEntitiesUndoRedoDesc);
 
@@ -2197,7 +2197,7 @@ namespace AzToolsFramework
             m_actions, { QKeySequence(Qt::CTRL + Qt::Key_A) }, SelectAll, s_selectAllTitle, s_selectAllDesc,
             [this]()
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+                AZ_PROFILE_FUNCTION(AzToolsFramework);
 
                 ScopedUndoBatch undoBatch(s_selectAllEntitiesUndoRedoDesc);
 
@@ -2237,7 +2237,7 @@ namespace AzToolsFramework
             m_actions, { QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_I) }, InvertSelect, s_invertSelectionTitle, s_invertSelectionDesc,
             [this]()
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+                AZ_PROFILE_FUNCTION(AzToolsFramework);
 
                 ScopedUndoBatch undoBatch(s_invertSelectionUndoRedoDesc);
 
@@ -2284,7 +2284,7 @@ namespace AzToolsFramework
             m_actions, { QKeySequence(Qt::CTRL + Qt::Key_D) }, DuplicateSelect, s_duplicateTitle, s_duplicateDesc,
             []()
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+                AZ_PROFILE_FUNCTION(AzToolsFramework);
 
                 // Clear Widget selection - Prevents issues caused by cloning entities while a property in the Reflected Property Editor
                 // is being edited.
@@ -2309,7 +2309,7 @@ namespace AzToolsFramework
             m_actions, { QKeySequence(Qt::Key_Delete) }, DeleteSelect, s_deleteTitle, s_deleteDesc,
             [this]()
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+                AZ_PROFILE_FUNCTION(AzToolsFramework);
 
                 ScopedUndoBatch undoBatch(s_deleteUndoRedoDesc);
 
@@ -2419,7 +2419,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::UnregisterManipulator()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (m_entityIdManipulators.m_manipulators && m_entityIdManipulators.m_manipulators->Registered())
         {
@@ -2429,7 +2429,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::RegisterManipulator()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (m_entityIdManipulators.m_manipulators && !m_entityIdManipulators.m_manipulators->Registered())
         {
@@ -2439,7 +2439,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::CreateEntityIdManipulators()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (m_selectedEntityIds.empty())
         {
@@ -2469,7 +2469,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::RegenerateManipulators()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // note: create/destroy pattern to be addressed
         DestroyManipulators(m_entityIdManipulators);
@@ -2636,7 +2636,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::SnapSelectedEntitiesToWorldGrid(const float gridSize)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const AZStd::array snapAxes = { AZ::Vector3::CreateAxisX(), AZ::Vector3::CreateAxisY(), AZ::Vector3::CreateAxisZ() };
 
@@ -2658,7 +2658,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::SetTransformMode(const Mode mode)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (mode == m_mode)
         {
@@ -2725,7 +2725,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::AddEntityToSelection(const AZ::EntityId entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         m_selectedEntityIds.insert(entityId);
 
         AZ::TransformNotificationBus::MultiHandler::BusConnect(entityId);
@@ -2733,7 +2733,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::RemoveEntityFromSelection(const AZ::EntityId entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         m_selectedEntityIds.erase(entityId);
 
         AZ::TransformNotificationBus::MultiHandler::BusDisconnect(entityId);
@@ -2746,7 +2746,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::SetSelectedEntities(const EntityIdList& entityIds)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // we are responsible for updating the current selection
         m_didSetSelectedEntities = true;
@@ -2755,7 +2755,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::RefreshManipulators(const RefreshType refreshType)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (m_entityIdManipulators.m_manipulators)
         {
@@ -2793,7 +2793,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::OverrideManipulatorOrientation(const AZ::Quaternion& orientation)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         m_pivotOverrideFrame.m_orientationOverride = orientation;
 
@@ -2808,7 +2808,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::OverrideManipulatorTranslation(const AZ::Vector3& translation)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         m_pivotOverrideFrame.m_translationOverride = translation;
 
@@ -2821,7 +2821,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::ClearManipulatorTranslationOverride()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (m_entityIdManipulators.m_manipulators)
         {
@@ -2847,7 +2847,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::ClearManipulatorOrientationOverride()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (m_entityIdManipulators.m_manipulators)
         {
@@ -2875,7 +2875,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::ToggleCenterPivotSelection()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         m_pivotMode = TogglePivotMode(m_pivotMode);
         RefreshManipulators(RefreshType::Translation);
     }
@@ -2883,7 +2883,7 @@ namespace AzToolsFramework
     template<typename EntityIdMap>
     static bool ShouldUpdateEntityTransform(const AZ::EntityId entityId, const EntityIdMap& entityIdMap)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         static_assert(AZStd::is_same<typename EntityIdMap::key_type, AZ::EntityId>::value, "Container key type is not an EntityId");
 
@@ -2907,7 +2907,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::CopyTranslationToSelectedEntitiesGroup(const AZ::Vector3& translation)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (m_mode != Mode::Translation)
         {
@@ -2963,7 +2963,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::CopyTranslationToSelectedEntitiesIndividual(const AZ::Vector3& translation)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (m_mode != Mode::Translation)
         {
@@ -3008,7 +3008,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::CopyScaleToSelectedEntitiesIndividualWorld(float scale)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         ScopedUndoBatch undoBatch(s_dittoScaleIndividualWorldUndoRedoDesc);
 
@@ -3042,7 +3042,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::CopyScaleToSelectedEntitiesIndividualLocal(float scale)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         ScopedUndoBatch undoBatch(s_dittoScaleIndividualLocalUndoRedoDesc);
 
@@ -3061,7 +3061,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::CopyOrientationToSelectedEntitiesIndividual(const AZ::Quaternion& orientation)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (m_entityIdManipulators.m_manipulators)
         {
@@ -3099,7 +3099,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::CopyOrientationToSelectedEntitiesGroup(const AZ::Quaternion& orientation)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (m_entityIdManipulators.m_manipulators)
         {
@@ -3147,7 +3147,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::ResetOrientationForSelectedEntitiesLocal()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         ScopedUndoBatch undoBatch(s_resetOrientationToParentUndoRedoDesc);
         for (const auto& entityIdLookup : m_entityIdManipulators.m_lookups)
@@ -3166,7 +3166,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::ResetTranslationForSelectedEntitiesLocal()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (m_entityIdManipulators.m_manipulators)
         {
@@ -3236,7 +3236,7 @@ namespace AzToolsFramework
     void EditorTransformComponentSelection::AfterEntitySelectionChanged(
         [[maybe_unused]] const EntityIdList& newlySelectedEntities, [[maybe_unused]] const EntityIdList& newlyDeselectedEntities)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // EditorTransformComponentSelection was not responsible for the change in selection
         if (!m_didSetSelectedEntities)
@@ -3265,7 +3265,7 @@ namespace AzToolsFramework
         const float axisLength,
         const AzFramework::CameraState& cameraState)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const int prevState = display.GetState();
 
@@ -3318,7 +3318,7 @@ namespace AzToolsFramework
     void EditorTransformComponentSelection::DisplayViewportSelection(
         const AzFramework::ViewportInfo& viewportInfo, AzFramework::DebugDisplayRequests& debugDisplay)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         CheckDirtyEntityIds();
 
@@ -3536,7 +3536,7 @@ namespace AzToolsFramework
     void EditorTransformComponentSelection::DisplayViewportSelection2d(
         const AzFramework::ViewportInfo& viewportInfo, AzFramework::DebugDisplayRequests& debugDisplay)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         DrawAxisGizmo(viewportInfo, debugDisplay);
 
@@ -3545,7 +3545,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::RefreshSelectedEntityIds()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // check what the 'authoritative' selected entity ids are after an undo/redo
         EntityIdList selectedEntityIds;
@@ -3556,7 +3556,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::RefreshSelectedEntityIds(const EntityIdList& selectedEntityIds)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         AZ::TransformNotificationBus::MultiHandler::BusDisconnect();
         for (const AZ::EntityId& entityId : selectedEntityIds)
@@ -3573,7 +3573,7 @@ namespace AzToolsFramework
     void EditorTransformComponentSelection::OnTransformChanged(
         [[maybe_unused]] const AZ::Transform& localTM, [[maybe_unused]] const AZ::Transform& worldTM)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (!m_transformChangedInternally)
         {
@@ -3583,7 +3583,7 @@ namespace AzToolsFramework
 
     void EditorTransformComponentSelection::OnViewportViewEntityChanged(const AZ::EntityId& newViewId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // if a viewport view entity has been set (e.g. we have set EditorCameraComponent to
         // match the editor camera translation/orientation), record the entity id if we have
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorVisibleEntityDataCache.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorVisibleEntityDataCache.cpp
index f371805997..c65f494b72 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorVisibleEntityDataCache.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorVisibleEntityDataCache.cpp
@@ -157,7 +157,7 @@ namespace AzToolsFramework
 
     void EditorVisibleEntityDataCache::CalculateVisibleEntityDatas(const AzFramework::ViewportInfo& viewportInfo)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // request list of visible entities from authoritative system
         EntityIdList nextVisibleEntityIds;
@@ -288,7 +288,7 @@ namespace AzToolsFramework
 
     void EditorVisibleEntityDataCache::OnEntityVisibilityChanged(const bool visibility)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const AZ::EntityId entityId = *EditorEntityVisibilityNotificationBus::GetCurrentBusId();
 
@@ -300,7 +300,7 @@ namespace AzToolsFramework
 
     void EditorVisibleEntityDataCache::OnEntityLockChanged(const bool locked)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const AZ::EntityId entityId = *EditorEntityLockComponentNotificationBus::GetCurrentBusId();
 
@@ -312,7 +312,7 @@ namespace AzToolsFramework
 
     void EditorVisibleEntityDataCache::OnTransformChanged(const AZ::Transform& /*local*/, const AZ::Transform& world)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const AZ::EntityId entityId = *AZ::TransformNotificationBus::GetCurrentBusId();
 
@@ -324,7 +324,7 @@ namespace AzToolsFramework
 
     void EditorVisibleEntityDataCache::OnAccentTypeChanged(const EntityAccentType accent)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const AZ::EntityId entityId = *EditorComponentSelectionNotificationsBus::GetCurrentBusId();
 
@@ -336,7 +336,7 @@ namespace AzToolsFramework
 
     void EditorVisibleEntityDataCache::OnSelected()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const AZ::EntityId entityId = *EntitySelectionEvents::Bus::GetCurrentBusId();
 
@@ -348,7 +348,7 @@ namespace AzToolsFramework
 
     void EditorVisibleEntityDataCache::OnDeselected()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const AZ::EntityId entityId = *EntitySelectionEvents::Bus::GetCurrentBusId();
 
@@ -360,7 +360,7 @@ namespace AzToolsFramework
 
     void EditorVisibleEntityDataCache::OnEntityIconChanged(const AZ::Data::AssetId& /*entityIconAssetId*/)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const AZ::EntityId entityId = *EditorEntityIconComponentNotificationBus::GetCurrentBusId();
 
diff --git a/Code/Framework/GridMate/GridMate/Replica/Replica.cpp b/Code/Framework/GridMate/GridMate/Replica/Replica.cpp
index 5d0949bbe8..c1de3b71f2 100644
--- a/Code/Framework/GridMate/GridMate/Replica/Replica.cpp
+++ b/Code/Framework/GridMate/GridMate/Replica/Replica.cpp
@@ -40,7 +40,7 @@ namespace GridMate
         , m_priority(0)
         , m_revision(1)
     {
-        AZ_PROFILE_TIMER("GridMate");
+        AZ_PROFILE_FUNCTION(GridMate);
 
         m_upstreamHop = nullptr;
         m_dirtyHook.m_next = m_dirtyHook.m_prev = nullptr;
@@ -86,7 +86,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     void Replica::PreDestruct()
     {
-        AZ_PROFILE_TIMER("GridMate");
+        AZ_PROFILE_FUNCTION(GridMate);
 
         for (auto chunk : m_chunks)
         {
@@ -137,7 +137,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     bool Replica::AttachReplicaChunk(const ReplicaChunkPtr& chunk)
     {
-        AZ_PROFILE_TIMER("GridMate");
+        AZ_PROFILE_FUNCTION(GridMate);
 
         // Check for duplicate attach
         if (!chunk->GetReplica())
@@ -174,7 +174,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     bool Replica::DetachReplicaChunk(const ReplicaChunkPtr& chunk)
     {
-        AZ_PROFILE_TIMER("GridMate");
+        AZ_PROFILE_FUNCTION(GridMate);
 
         if (!IsActive())
         {
@@ -213,7 +213,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     void Replica::UpdateReplica(const ReplicaContext& rc)
     {
-        AZ_PROFILE_TIMER("GridMate");
+        AZ_PROFILE_FUNCTION(GridMate);
 
         for (auto chunk : m_chunks)
         {
@@ -226,7 +226,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     void Replica::UpdateFromReplica(const ReplicaContext& rc)
     {
-        AZ_PROFILE_TIMER("GridMate");
+        AZ_PROFILE_FUNCTION(GridMate);
 
         for (auto chunk : m_chunks)
         {
@@ -239,7 +239,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     bool Replica::AcceptChangeOwnership(PeerId requestor, const ReplicaContext& rc)
     {
-        AZ_PROFILE_TIMER("GridMate");
+        AZ_PROFILE_FUNCTION(GridMate);
 
         for (auto chunk : m_chunks)
         {
@@ -274,7 +274,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     void Replica::OnDeactivate(const ReplicaContext& rc)
     {
-        AZ_PROFILE_TIMER("GridMate");
+        AZ_PROFILE_FUNCTION(GridMate);
 
         EBUS_EVENT_ID(rc.m_rm->GetGridMate(), ReplicaMgrCallbackBus, OnDeactivateReplica, GetRepId(), rc.m_rm);
         EBUS_EVENT(Debug::ReplicaDrillerBus, OnDeactivateReplica, this);
@@ -294,7 +294,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     void Replica::OnChangeOwnership(const ReplicaContext& rc)
     {
-        AZ_PROFILE_TIMER("GridMate");
+        AZ_PROFILE_FUNCTION(GridMate);
 
         for (auto chunk : m_chunks)
         {
@@ -319,7 +319,7 @@ namespace GridMate
     {
         (void) rpcContext;
 
-        AZ_PROFILE_TIMER("GridMate");
+        AZ_PROFILE_FUNCTION(GridMate);
 
         if (IsActive())
         {
@@ -382,7 +382,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     void Replica::Activate(const ReplicaContext& rc)
     {
-        AZ_PROFILE_TIMER("GridMate");
+        AZ_PROFILE_FUNCTION(GridMate);
 
         // Resolve whether we're migratable or not from the chunks
         // present when we're attached to the network.
@@ -410,7 +410,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     void Replica::Deactivate(const ReplicaContext& rc)
     {
-        AZ_PROFILE_TIMER("GridMate");
+        AZ_PROFILE_FUNCTION(GridMate);
 
         if (IsActive())
         {
@@ -440,7 +440,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     bool Replica::ProcessRPCs(const ReplicaContext& rc)
     {
-        AZ_PROFILE_TIMER("GridMate");
+        AZ_PROFILE_FUNCTION(GridMate);
 
         bool isProcessed = true;
         for (auto chunk : m_chunks)
@@ -508,7 +508,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     PrepareDataResult Replica::PrepareData(EndianType endianType, AZ::u32 marshalFlags)
     {
-        //AZ_PROFILE_TIMER("GridMate");
+        //AZ_PROFILE_SCOPE("GridMate");
 
         PrepareDataResult pdr(false, false, false, false);
         bool dataSetChange = false;
@@ -536,7 +536,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     void Replica::Marshal(MarshalContext& mc)
     {
-        //AZ_PROFILE_TIMER("GridMate");
+        //AZ_PROFILE_SCOPE("GridMate");
 
         // We are going to replace the outBuffer with a temporary chunk buffer for each chunk,
         // hold on to the original so we can restore it later and write the chunk buffers into
@@ -639,7 +639,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     bool Replica::Unmarshal(UnmarshalContext& mc)
     {
-        AZ_PROFILE_TIMER("GridMate");
+        AZ_PROFILE_FUNCTION(GridMate);
 
         UnmarshalContext chunkContext(mc);
         ReadBuffer& buffer = *mc.m_iBuf;
@@ -715,7 +715,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     ReplicaChunkPtr Replica::CreateReplicaChunkFromStream(ReplicaChunkClassId classId, UnmarshalContext& mc)
     {
-        AZ_PROFILE_TIMER("GridMate");
+        AZ_PROFILE_FUNCTION(GridMate);
 
         ReplicaChunkPtr chunk = nullptr;
         ReplicaChunkDescriptor* pDesc = ReplicaChunkDescriptorTable::Get().FindReplicaChunkDescriptor(classId);
diff --git a/Code/Framework/GridMate/GridMate/Replica/ReplicaChunk.cpp b/Code/Framework/GridMate/GridMate/Replica/ReplicaChunk.cpp
index 07b056d3bb..ee42ff2ad0 100644
--- a/Code/Framework/GridMate/GridMate/Replica/ReplicaChunk.cpp
+++ b/Code/Framework/GridMate/GridMate/Replica/ReplicaChunk.cpp
@@ -152,7 +152,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     PrepareDataResult ReplicaChunkBase::PrepareData(EndianType endianType, AZ::u32 marshalFlags)
     {
-        //AZ_PROFILE_TIMER("GridMate");
+        //AZ_PROFILE_SCOPE("GridMate");
 
         PrepareDataResult pdr(false, false, false, false);
         bool forceDatasetsReliable = !!(marshalFlags & ReplicaMarshalFlags::ForceReliable);
@@ -250,7 +250,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     bool ReplicaChunkBase::ShouldSendToPeer(ReplicaPeer* peer) const
     {
-        //AZ_PROFILE_TIMER("GridMate");
+        //AZ_PROFILE_SCOPE("GridMate");
 
         // Only send chunks to the same zone as the peer
         return !!(peer->GetZoneMask() & GetDescriptor()->GetZoneMask());
@@ -258,7 +258,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     void ReplicaChunkBase::Marshal(MarshalContext& mc, AZ::u32 chunkIndex)
     {
-        //AZ_PROFILE_TIMER("GridMate");
+        //AZ_PROFILE_SCOPE("GridMate");
 
         SafeGuardWrite(mc.m_outBuffer, [this, &mc, &chunkIndex]()
         {
@@ -269,7 +269,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     void ReplicaChunkBase::Unmarshal(UnmarshalContext& mc, AZ::u32 chunkIndex)
     {
-        AZ_PROFILE_TIMER("GridMate");
+        AZ_PROFILE_FUNCTION(GridMate);
 
         SafeGuardRead(mc.m_iBuf, [this, &mc, &chunkIndex]()
         {
@@ -334,7 +334,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     void ReplicaChunkBase::MarshalDataSets(MarshalContext& mc, AZ::u32 chunkIndex)
     {
-        //AZ_PROFILE_TIMER("GridMate");
+        //AZ_PROFILE_SCOPE("GridMate");
         AZ::u32 dirtyDataSetMask = CalculateDirtyDataSetMask(mc);
         AZStd::bitset<GM_MAX_DATASETS_IN_CHUNK> changebits(dirtyDataSetMask);
         ReplicaChunkDescriptor* descriptor = GetDescriptor();
@@ -382,7 +382,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     void ReplicaChunkBase::UnmarshalDataSets(UnmarshalContext& mc, AZ::u32 chunkIndex)
     {
-        AZ_PROFILE_TIMER("GridMate");
+        AZ_PROFILE_FUNCTION(GridMate);
 
         AZStd::bitset<GM_MAX_DATASETS_IN_CHUNK> changebits;
         if (!mc.m_iBuf->Read(*changebits.data(), VlqU32Marshaler()))
@@ -438,7 +438,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     void ReplicaChunkBase::MarshalRpcs(MarshalContext& mc, AZ::u32 chunkIndex)
     {
-        //AZ_PROFILE_TIMER("GridMate");
+        //AZ_PROFILE_SCOPE("GridMate");
 
         bool isAuthoritative = (mc.m_marshalFlags & ReplicaMarshalFlags::Authoritative) == ReplicaMarshalFlags::Authoritative;
         bool isReliable = (mc.m_marshalFlags & ReplicaMarshalFlags::Reliable) == ReplicaMarshalFlags::Reliable;
@@ -496,7 +496,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     void ReplicaChunkBase::UnmarshalRpcs(UnmarshalContext& mc, AZ::u32 chunkIndex)
     {
-        AZ_PROFILE_TIMER("GridMate");
+        AZ_PROFILE_FUNCTION(GridMate);
 
         // Unmarshal RPCs
         AZ::u32 rpcCount;
@@ -629,7 +629,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     bool ReplicaChunkBase::ProcessRPCs(const ReplicaContext& rc)
     {
-        AZ_PROFILE_TIMER("GridMate");
+        AZ_PROFILE_FUNCTION(GridMate);
 
         // Process incoming RPCs
         for (RPCQueue::iterator iRPC = m_rpcQueue.begin(); iRPC != m_rpcQueue.end(); )
@@ -733,7 +733,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     void ReplicaChunkBase::AttachedToReplica(Replica* replica)
     {
-        AZ_PROFILE_TIMER("GridMate");
+        AZ_PROFILE_FUNCTION(GridMate);
 
         AZ_Assert(!m_replica, "Should not be attached to a replica");
 
@@ -748,7 +748,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     void ReplicaChunkBase::DetachedFromReplica()
     {
-        AZ_PROFILE_TIMER("GridMate");
+        AZ_PROFILE_FUNCTION(GridMate);
 
         AZ_Assert(m_replica, "Should be attached to a replica");
         EBUS_EVENT(Debug::ReplicaDrillerBus, OnDetachReplicaChunk, this);
diff --git a/Code/Framework/GridMate/GridMate/Replica/ReplicaMgr.cpp b/Code/Framework/GridMate/GridMate/Replica/ReplicaMgr.cpp
index b8eea00871..f1b91fa1ad 100644
--- a/Code/Framework/GridMate/GridMate/Replica/ReplicaMgr.cpp
+++ b/Code/Framework/GridMate/GridMate/Replica/ReplicaMgr.cpp
@@ -700,7 +700,7 @@ namespace GridMate
     {
         if (IsUsingFixedTimeStep())
         {
-            return static_cast<AZ::u32>(m_fixedTimeStep.GetCurrentTime());
+            return static_cast<AZ::u32>(m_fixedTimeStep.CurrentTime());
         }
         else
         {
@@ -867,7 +867,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     void ReplicaManager::UpdateFromReplicas()
     {
-        AZ_PROFILE_TIMER("GridMate", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(GridMate);
 
         if (!IsInitialized())
         {
@@ -888,7 +888,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     void ReplicaManager::UpdateReplicas()
     {
-        AZ_PROFILE_TIMER("GridMate", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(GridMate);
 
         if (!IsInitialized())
         {
@@ -940,7 +940,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     void ReplicaManager::Marshal()
     {
-        AZ_PROFILE_TIMER("GridMate", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(GridMate);
 
         if (!IsReady())
         {
@@ -1287,7 +1287,7 @@ namespace GridMate
     //-----------------------------------------------------------------------------
     void ReplicaManager::Unmarshal()
     {
-        AZ_PROFILE_TIMER("GridMate", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(GridMate);
 
         if (!IsInitialized())
         {
diff --git a/Code/Framework/GridMate/GridMate/Replica/ReplicaMgr.h b/Code/Framework/GridMate/GridMate/Replica/ReplicaMgr.h
index bd9f1a1ee9..bedff54939 100644
--- a/Code/Framework/GridMate/GridMate/Replica/ReplicaMgr.h
+++ b/Code/Framework/GridMate/GridMate/Replica/ReplicaMgr.h
@@ -302,7 +302,7 @@ namespace GridMate
             // this could allow for changing on the fly but it would need to ensure that if it were in the middle of a second, that the new rate would result in landing on the
         }
 
-        AZ::u64 GetCurrentTime() const
+        AZ::u64 CurrentTime() const
         {
             return m_currentTime;
         }
diff --git a/Code/Framework/GridMate/GridMate/Replica/ReplicaUtils.h b/Code/Framework/GridMate/GridMate/Replica/ReplicaUtils.h
index 6833aa9234..8de2abab6e 100644
--- a/Code/Framework/GridMate/GridMate/Replica/ReplicaUtils.h
+++ b/Code/Framework/GridMate/GridMate/Replica/ReplicaUtils.h
@@ -81,7 +81,7 @@ namespace GridMate
 #define GM_ENABLE_PROFILE_USER_CALLBACKS 1
 
 #if (GM_ENABLE_PROFILE_USER_CALLBACKS)
-#define GM_PROFILE_USER_CALLBACK(callback) AZ_PROFILE_TIMER("GridMate User Code", callback);
+#define GM_PROFILE_USER_CALLBACK(callback) AZ_PROFILE_SCOPE(GridMate, "GridMate User Code: %s", callback);
 #else
 #define GM_PROFILE_USER_CALLBACK(callback)
 #endif
diff --git a/Code/Legacy/CryCommon/FrameProfiler.h b/Code/Legacy/CryCommon/FrameProfiler.h
index 12eb6a34a1..ac6d3a52a1 100644
--- a/Code/Legacy/CryCommon/FrameProfiler.h
+++ b/Code/Legacy/CryCommon/FrameProfiler.h
@@ -43,32 +43,25 @@ enum EProfiledSubsystem
 };
 #undef X
 
-static_assert(static_cast<AZ::Debug::ProfileCategory>(PROFILE_LAST_SUBSYSTEM) == AZ::Debug::ProfileCategory::LegacyLast, "Mismatched AZ and Legacy profile categories");
 #include <AzCore/Debug/EventTrace.h>
 
 
 
 #define FUNCTION_PROFILER_LEGACYONLY(pISystem, subsystem)
 
-#define FUNCTION_PROFILER(pISystem, subsystem) \
-    AZ_PROFILE_FUNCTION(static_cast<AZ::Debug::ProfileCategory>(subsystem));
+#define FUNCTION_PROFILER(pISystem, subsystem)
 
-#define FUNCTION_PROFILER_FAST(pISystem, subsystem, bProfileEnabled) \
-    AZ_PROFILE_FUNCTION(static_cast<AZ::Debug::ProfileCategory>(subsystem));
+#define FUNCTION_PROFILER_FAST(pISystem, subsystem, bProfileEnabled)
 
-#define FUNCTION_PROFILER_ALWAYS(pISystem, subsystem) \
-    AZ_PROFILE_FUNCTION(static_cast<AZ::Debug::ProfileCategory>(subsystem));
+#define FUNCTION_PROFILER_ALWAYS(pISystem, subsystem)
 
 #define FRAME_PROFILER_LEGACYONLY(szProfilerName, pISystem, subsystem)
 
-#define FRAME_PROFILER(szProfilerName, pISystem, subsystem) \
-    AZ_PROFILE_SCOPE(static_cast<AZ::Debug::ProfileCategory>(subsystem), szProfilerName);
+#define FRAME_PROFILER(szProfilerName, pISystem, subsystem)
 
-#define FRAME_PROFILER_FAST(szProfilerName, pISystem, subsystem, bProfileEnabled) \
-    AZ_PROFILE_SCOPE(static_cast<AZ::Debug::ProfileCategory>(subsystem), szProfilerName);
+#define FRAME_PROFILER_FAST(szProfilerName, pISystem, subsystem, bProfileEnabled)
 
-#define FUNCTION_PROFILER_SYS(subsystem) \
-    FUNCTION_PROFILER(gEnv->pSystem, PROFILE_##subsystem)
+#define FUNCTION_PROFILER_SYS(subsystem)
 
 #define STALL_PROFILER(cause)
 
diff --git a/Code/Legacy/CryCommon/ISystem.h b/Code/Legacy/CryCommon/ISystem.h
index ff72c2e60f..d8aba337d5 100644
--- a/Code/Legacy/CryCommon/ISystem.h
+++ b/Code/Legacy/CryCommon/ISystem.h
@@ -1151,10 +1151,10 @@ struct DiskOperationInfo
 
 #if defined(ENABLE_LOADING_PROFILER) && AZ_PROFILE_TELEMETRY
 
-#define LOADING_TIME_PROFILE_SECTION AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore)
-#define LOADING_TIME_PROFILE_SECTION_ARGS(...) AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, __VA_ARGS__)
-#define LOADING_TIME_PROFILE_SECTION_NAMED(sectionName) AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, sectionName)
-#define LOADING_TIME_PROFILE_SECTION_NAMED_ARGS(sectionName, ...) AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, sectionName, __VA_ARGS__)
+#define LOADING_TIME_PROFILE_SECTION AZ_PROFILE_FUNCTION(AzCore)
+#define LOADING_TIME_PROFILE_SECTION_ARGS(...) AZ_PROFILE_SCOPE(AzCore, __VA_ARGS__)
+#define LOADING_TIME_PROFILE_SECTION_NAMED(sectionName) AZ_PROFILE_SCOPE(AzCore, sectionName)
+#define LOADING_TIME_PROFILE_SECTION_NAMED_ARGS(sectionName, ...) AZ_PROFILE_SCOPE(AzCore, sectionName, __VA_ARGS__)
 
 #else
 
diff --git a/Code/Legacy/CryCommon/LegacyAllocator.h b/Code/Legacy/CryCommon/LegacyAllocator.h
index 074c183de4..18af1400d5 100644
--- a/Code/Legacy/CryCommon/LegacyAllocator.h
+++ b/Code/Legacy/CryCommon/LegacyAllocator.h
@@ -69,7 +69,7 @@ namespace AZ
             }
 
             pointer_type ptr = m_schema->Allocate(byteSize, alignment, flags, name, fileName, lineNum, suppressStackRecord);
-            AZ_PROFILE_MEMORY_ALLOC_EX(AZ::Debug::ProfileCategory::MemoryReserved, fileName, lineNum, ptr, byteSize, name ? name : GetName());
+            AZ_PROFILE_MEMORY_ALLOC_EX(MemoryReserved, fileName, lineNum, ptr, byteSize, name ? name : GetName());
             AZ_MEMORY_PROFILE(ProfileAllocation(ptr, byteSize, alignment, name, fileName, lineNum, suppressStackRecord));
             AZ_Assert(ptr || byteSize == 0, "OOM - Failed to allocate %zu bytes from LegacyAllocator", byteSize);
             return ptr;
@@ -78,7 +78,7 @@ namespace AZ
         // DeAllocate with file/line, to track when allocs were freed from Cry
         void DeAllocate(pointer_type ptr, [[maybe_unused]] const char* file, [[maybe_unused]] const int line, size_type byteSize = 0, size_type alignment = 0)
         {
-            AZ_PROFILE_MEMORY_FREE_EX(AZ::Debug::ProfileCategory::MemoryReserved, file, line, ptr);
+            AZ_PROFILE_MEMORY_FREE_EX(MemoryReserved, file, line, ptr);
             AZ_MEMORY_PROFILE(ProfileDeallocation(ptr, byteSize, alignment, nullptr));
             m_schema->DeAllocate(ptr, byteSize, alignment);
         }
@@ -94,9 +94,9 @@ namespace AZ
             }
 
             AZ_MEMORY_PROFILE(ProfileReallocationBegin(ptr, newSize));
-            AZ_PROFILE_MEMORY_FREE_EX(AZ::Debug::ProfileCategory::MemoryReserved, file, line, ptr);
+            AZ_PROFILE_MEMORY_FREE_EX(MemoryReserved, file, line, ptr);
             pointer_type newPtr = m_schema->ReAllocate(ptr, newSize, newAlignment);
-            AZ_PROFILE_MEMORY_ALLOC_EX(AZ::Debug::ProfileCategory::MemoryReserved, file, line, newPtr, newSize, "LegacyAllocator Realloc");
+            AZ_PROFILE_MEMORY_ALLOC_EX(MemoryReserved, file, line, newPtr, newSize, "LegacyAllocator Realloc");
             AZ_MEMORY_PROFILE(ProfileReallocationEnd(ptr, newPtr, newSize, newAlignment));
             AZ_Assert(newPtr || newSize == 0, "OOM - Failed to reallocate %zu bytes from LegacyAllocator", newSize);
             return newPtr;
diff --git a/Code/Legacy/CryCommon/platform_impl.cpp b/Code/Legacy/CryCommon/platform_impl.cpp
index 4263d813b7..dc8a555286 100644
--- a/Code/Legacy/CryCommon/platform_impl.cpp
+++ b/Code/Legacy/CryCommon/platform_impl.cpp
@@ -203,7 +203,7 @@ void __stl_debug_message(const char* format_str, ...)
 //////////////////////////////////////////////////////////////////////////
 void CrySleep(unsigned int dwMilliseconds)
 {
-    AZ_PROFILE_FUNCTION_IDLE(AZ::Debug::ProfileCategory::System);
+    AZ_PROFILE_FUNCTION(System);
     Sleep(dwMilliseconds);
 }
 
diff --git a/Code/Legacy/CrySystem/System.cpp b/Code/Legacy/CrySystem/System.cpp
index 3673088695..d848160b3e 100644
--- a/Code/Legacy/CrySystem/System.cpp
+++ b/Code/Legacy/CrySystem/System.cpp
@@ -701,7 +701,7 @@ void CSystem::SleepIfNeeded()
     int sleepMS = (int)(1000.0f * sleepTime + 0.5f);
     if (sleepMS > 0)
     {
-        AZ_PROFILE_FUNCTION_IDLE(AZ::Debug::ProfileCategory::System);
+        AZ_PROFILE_FUNCTION(System);
         Sleep(sleepMS);
     }
 
diff --git a/Code/Tools/SceneAPI/SceneUI/SceneWidgets/ManifestWidget.cpp b/Code/Tools/SceneAPI/SceneUI/SceneWidgets/ManifestWidget.cpp
index 6cec14a9c5..eba43d2e36 100644
--- a/Code/Tools/SceneAPI/SceneUI/SceneWidgets/ManifestWidget.cpp
+++ b/Code/Tools/SceneAPI/SceneUI/SceneWidgets/ManifestWidget.cpp
@@ -40,7 +40,7 @@ namespace AZ
 
             void ManifestWidget::BuildFromScene(const AZStd::shared_ptr<Containers::Scene>& scene)
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+                AZ_PROFILE_FUNCTION(Editor);
                 ui->m_tabs->clear();
                 m_pages.clear();
                 
@@ -80,7 +80,7 @@ namespace AZ
 
             bool ManifestWidget::AddObject(const AZStd::shared_ptr<DataTypes::IManifestObject>& object)
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+                AZ_PROFILE_FUNCTION(Editor);
                 for (ManifestWidgetPage* page : m_pages)
                 {
                     if (page->SupportsType(object))
diff --git a/Code/Tools/SceneAPI/SceneUI/SceneWidgets/ManifestWidgetPage.cpp b/Code/Tools/SceneAPI/SceneUI/SceneWidgets/ManifestWidgetPage.cpp
index 118db8217e..cd80b68509 100644
--- a/Code/Tools/SceneAPI/SceneUI/SceneWidgets/ManifestWidgetPage.cpp
+++ b/Code/Tools/SceneAPI/SceneUI/SceneWidgets/ManifestWidgetPage.cpp
@@ -76,7 +76,7 @@ namespace AZ
 
             bool ManifestWidgetPage::AddObject(const AZStd::shared_ptr<DataTypes::IManifestObject>& object)
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+                AZ_PROFILE_FUNCTION(Editor);
                 if (!SupportsType(object))
                 {
                     return false;
@@ -218,7 +218,7 @@ namespace AZ
 
             void ManifestWidgetPage::RefreshPage()
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Editor);
+                AZ_PROFILE_FUNCTION(Editor);
                 m_propertyEditor->InvalidateAll();
                 m_propertyEditor->ExpandAll();
             }
diff --git a/Code/Tools/Standalone/Source/Driller/AreaChart.cpp b/Code/Tools/Standalone/Source/Driller/AreaChart.cpp
index c672e4414a..fef31aaaf3 100644
--- a/Code/Tools/Standalone/Source/Driller/AreaChart.cpp
+++ b/Code/Tools/Standalone/Source/Driller/AreaChart.cpp
@@ -231,14 +231,14 @@ namespace AreaChart
     
     void AreaChart::AddPoint(size_t seriesId, int position, unsigned int value)
     {
-        AZ_PROFILE_TIMER("Standalone Tools", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         LinePoint linePoint(position,value);
         AddPoint(seriesId,linePoint);
     }
     
     void AreaChart::AddPoint(size_t seriesId, const LinePoint& linePoint)
     {
-        AZ_PROFILE_TIMER("Standalone Tools", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         if (!IsValidSeriesId(seriesId))
         {
             AZ_Error("AreaChart", false, "Invalid SeriesId given.");
@@ -419,7 +419,7 @@ namespace AreaChart
     
     void AreaChart::paintEvent(QPaintEvent* event)
     {
-        AZ_PROFILE_TIMER("Standalone Tools", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         (void)event;
         
         if (m_sizingDirty)
@@ -435,7 +435,7 @@ namespace AreaChart
 
         if (m_regenGraph)
         {
-            AZ_PROFILE_TIMER("Standalone Tools", "Generating Graph Data");
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
             m_regenGraph = false;
 
             if (m_verticalAxis)
diff --git a/Code/Tools/Standalone/Source/Driller/Replica/BaseDetailView.h b/Code/Tools/Standalone/Source/Driller/Replica/BaseDetailView.h
index 8b7e3f36af..2db8966a2e 100644
--- a/Code/Tools/Standalone/Source/Driller/Replica/BaseDetailView.h
+++ b/Code/Tools/Standalone/Source/Driller/Replica/BaseDetailView.h
@@ -203,7 +203,7 @@ namespace Driller
 
         void RedrawGraph()
         {
-            AZ_PROFILE_TIMER("Standalone Tools", __FUNCTION__);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
             switch (m_displayMode)
             {
             case DisplayMode::Active:
@@ -518,7 +518,7 @@ namespace Driller
 
         void RefreshView(FrameNumberType frameId)
         {
-            AZ_PROFILE_TIMER("Standalone Tools", __FUNCTION__);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
             AZStd::unordered_set< Key > discoveredSet;
 
             m_tableViewOrdering.clear();
diff --git a/Code/Tools/Standalone/Source/Driller/Replica/ReplicaDataView.cpp b/Code/Tools/Standalone/Source/Driller/Replica/ReplicaDataView.cpp
index e538b47429..be4c7d14ff 100644
--- a/Code/Tools/Standalone/Source/Driller/Replica/ReplicaDataView.cpp
+++ b/Code/Tools/Standalone/Source/Driller/Replica/ReplicaDataView.cpp
@@ -1628,7 +1628,7 @@ namespace Driller
 
     void ReplicaDataView::ParseFrameData(FrameNumberType frameId)
     {
-        AZ_PROFILE_TIMER("Standalone Tools", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
         if (frameId < 0 || frameId >= m_aggregator->GetFrameCount() || m_parsedFrames.find(frameId) != m_parsedFrames.end())
         {
             return;
diff --git a/Gems/Atom/Asset/ImageProcessingAtom/Code/Include/Atom/ImageProcessing/ImageProcessingBus.h b/Gems/Atom/Asset/ImageProcessingAtom/Code/Include/Atom/ImageProcessing/ImageProcessingBus.h
index cb6c742722..fc89abfc9a 100644
--- a/Gems/Atom/Asset/ImageProcessingAtom/Code/Include/Atom/ImageProcessing/ImageProcessingBus.h
+++ b/Gems/Atom/Asset/ImageProcessingAtom/Code/Include/Atom/ImageProcessing/ImageProcessingBus.h
@@ -73,3 +73,4 @@ namespace ImageProcessingAtom
 
     using ImageBuilderRequestBus = AZ::EBus<ImageBuilderRequests>;
 } // namespace ImageProcessingAtom
+
diff --git a/Gems/Atom/Asset/ImageProcessingAtom/Code/Source/ImageBuilderComponent.h b/Gems/Atom/Asset/ImageProcessingAtom/Code/Source/ImageBuilderComponent.h
index 0d6ac5d959..0df628e9cd 100644
--- a/Gems/Atom/Asset/ImageProcessingAtom/Code/Source/ImageBuilderComponent.h
+++ b/Gems/Atom/Asset/ImageProcessingAtom/Code/Source/ImageBuilderComponent.h
@@ -94,3 +94,4 @@ namespace ImageProcessingAtom
         AZStd::vector<AZStd::unique_ptr<AZ::Data::AssetHandler>> m_assetHandlers;
     };
 }// namespace ImageProcessingAtom
+
diff --git a/Gems/Atom/Feature/Common/Code/Source/AuxGeom/AuxGeomDrawQueue.cpp b/Gems/Atom/Feature/Common/Code/Source/AuxGeom/AuxGeomDrawQueue.cpp
index 7f9bae7e49..214643505a 100644
--- a/Gems/Atom/Feature/Common/Code/Source/AuxGeom/AuxGeomDrawQueue.cpp
+++ b/Gems/Atom/Feature/Common/Code/Source/AuxGeom/AuxGeomDrawQueue.cpp
@@ -649,7 +649,7 @@ namespace AZ
             AZ::u8 width,
             int32_t viewProjOverrideIndex)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             // grab a mutex lock for the rest of this function so that a commit cannot happen during it and
             // other threads can't add geometry during it
@@ -720,7 +720,7 @@ namespace AZ
             AZ::u8 width,
             int32_t viewProjOverrideIndex)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_ATOM_PROFILE_FUNCTION("AuxGeom", "AuxGeomDrawQueue: DrawPrimitiveWithSharedVerticesCommon");
 
             AZ_Assert(indexCount >= verticesPerPrimitiveType && (indexCount % verticesPerPrimitiveType == 0),
diff --git a/Gems/Atom/Feature/Common/Code/Source/AuxGeom/FixedShapeProcessor.cpp b/Gems/Atom/Feature/Common/Code/Source/AuxGeom/FixedShapeProcessor.cpp
index f2b3a93a53..698b7e1e37 100644
--- a/Gems/Atom/Feature/Common/Code/Source/AuxGeom/FixedShapeProcessor.cpp
+++ b/Gems/Atom/Feature/Common/Code/Source/AuxGeom/FixedShapeProcessor.cpp
@@ -127,7 +127,7 @@ namespace AZ
 
         void FixedShapeProcessor::ProcessObjects(const AuxGeomBufferData* bufferData, const RPI::FeatureProcessor::RenderPacket& fpPacket)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_ATOM_PROFILE_FUNCTION("AuxGeom", "FixedShapeProcessor: ProcessObjects");
 
             RHI::DrawPacketBuilder drawPacketBuilder;
diff --git a/Gems/Atom/Feature/Common/Code/Source/Decals/DecalTextureArrayFeatureProcessor.cpp b/Gems/Atom/Feature/Common/Code/Source/Decals/DecalTextureArrayFeatureProcessor.cpp
index bda7e2463b..90fd926b99 100644
--- a/Gems/Atom/Feature/Common/Code/Source/Decals/DecalTextureArrayFeatureProcessor.cpp
+++ b/Gems/Atom/Feature/Common/Code/Source/Decals/DecalTextureArrayFeatureProcessor.cpp
@@ -145,7 +145,7 @@ namespace AZ
 
         void DecalTextureArrayFeatureProcessor::Simulate(const RPI::FeatureProcessor::SimulatePacket& packet)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender)
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_UNUSED(packet);
 
             if (m_deviceBufferNeedsUpdate)
@@ -159,7 +159,7 @@ namespace AZ
         void DecalTextureArrayFeatureProcessor::Render(const RPI::FeatureProcessor::RenderPacket& packet)
         {
             // Note that decals are rendered as part of the forward shading pipeline. We only need to bind the decal buffers/textures in here.
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender)
+            AZ_PROFILE_FUNCTION(AzRender);
 
             for (const RPI::ViewPtr& view : packet.m_views)
             {
@@ -295,7 +295,7 @@ namespace AZ
 
         void DecalTextureArrayFeatureProcessor::SetDecalMaterial(const DecalHandle handle, const AZ::Data::AssetId material)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Renderer);
+            AZ_PROFILE_FUNCTION(Renderer);
             if (handle.IsNull())
             {
                 AZ_Warning("DecalTextureArrayFeatureProcessor", false, "Invalid handle passed to DecalTextureArrayFeatureProcessor::SetDecalMaterial().");
@@ -365,7 +365,7 @@ namespace AZ
 
         void DecalTextureArrayFeatureProcessor::OnAssetReady(const Data::Asset<Data::AssetData> asset)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Renderer);
+            AZ_PROFILE_FUNCTION(Renderer);
             const Data::AssetId& assetId = asset->GetId();
             
             const RPI::MaterialAsset* materialAsset = asset.GetAs<AZ::RPI::MaterialAsset>();
diff --git a/Gems/Atom/Feature/Common/Code/Source/DiffuseGlobalIllumination/DiffuseProbeGridFeatureProcessor.cpp b/Gems/Atom/Feature/Common/Code/Source/DiffuseGlobalIllumination/DiffuseProbeGridFeatureProcessor.cpp
index 378e1923f7..543851da0f 100644
--- a/Gems/Atom/Feature/Common/Code/Source/DiffuseGlobalIllumination/DiffuseProbeGridFeatureProcessor.cpp
+++ b/Gems/Atom/Feature/Common/Code/Source/DiffuseGlobalIllumination/DiffuseProbeGridFeatureProcessor.cpp
@@ -111,7 +111,7 @@ namespace AZ
 
         void DiffuseProbeGridFeatureProcessor::Simulate([[maybe_unused]] const FeatureProcessor::SimulatePacket& packet)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             // update pipeline states
             if (m_needUpdatePipelineStates)
@@ -149,7 +149,7 @@ namespace AZ
             // if the volumes changed we need to re-sort the probe list
             if (m_probeGridSortRequired)
             {
-                AZ_PROFILE_SCOPE(Debug::ProfileCategory::AzRender, "Sort diffuse probe grids");
+                AZ_PROFILE_SCOPE(AzRender, "Sort diffuse probe grids");
 
                 // sort the probes by descending inner volume size, so the smallest volumes are rendered last
                 auto sortFn = [](AZStd::shared_ptr<DiffuseProbeGrid> const& probe1, AZStd::shared_ptr<DiffuseProbeGrid> const& probe2) -> bool
diff --git a/Gems/Atom/Feature/Common/Code/Source/ImGui/ImGuiPass.cpp b/Gems/Atom/Feature/Common/Code/Source/ImGui/ImGuiPass.cpp
index cd781390a3..f87a9b30e9 100644
--- a/Gems/Atom/Feature/Common/Code/Source/ImGui/ImGuiPass.cpp
+++ b/Gems/Atom/Feature/Common/Code/Source/ImGui/ImGuiPass.cpp
@@ -582,7 +582,7 @@ namespace AZ
 
         void ImGuiPass::BuildCommandListInternal(const RHI::FrameGraphExecuteContext& context)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_ATOM_PROFILE_FUNCTION("Pass", "ImGuiPass: Execute");
 
             context.GetCommandList()->SetViewport(m_viewportState);
@@ -612,7 +612,7 @@ namespace AZ
 
         uint32_t ImGuiPass::UpdateImGuiResources()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_ATOM_PROFILE_FUNCTION("Pass", "ImGuiPass: UpdateImGuiResources");
 
             auto imguiContextScope = ImguiContextScope(m_imguiContext);
diff --git a/Gems/Atom/Feature/Common/Code/Source/Mesh/MeshFeatureProcessor.cpp b/Gems/Atom/Feature/Common/Code/Source/Mesh/MeshFeatureProcessor.cpp
index 8e2c6f2e9b..58541da92a 100644
--- a/Gems/Atom/Feature/Common/Code/Source/Mesh/MeshFeatureProcessor.cpp
+++ b/Gems/Atom/Feature/Common/Code/Source/Mesh/MeshFeatureProcessor.cpp
@@ -75,7 +75,7 @@ namespace AZ
 
         void MeshFeatureProcessor::Simulate(const FeatureProcessor::SimulatePacket& packet)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_ATOM_PROFILE_FUNCTION("RPI", "MeshFeatureProcessor: Simulate");
             AZ_UNUSED(packet);
 
@@ -87,7 +87,7 @@ namespace AZ
             {
                 const auto jobLambda = [&]() -> void
                 {
-                    AZ_PROFILE_SCOPE(Debug::ProfileCategory::AzRender, "MeshFP::Simulate() Lambda");
+                    AZ_PROFILE_SCOPE(AzRender, "MeshFP::Simulate() Lambda");
                     for (auto meshDataIter = iteratorRange.first; meshDataIter != iteratorRange.second; ++meshDataIter)
                     {
                         if (!meshDataIter->m_model)
@@ -149,7 +149,7 @@ namespace AZ
             const MeshHandleDescriptor& descriptor,
             const MaterialAssignmentMap& materials)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             // don't need to check the concurrency during emplace() because the StableDynamicArray won't move the other elements during insertion
             MeshHandle meshDataHandle = m_meshData.emplace();
@@ -478,7 +478,7 @@ namespace AZ
             : m_modelAsset(modelAsset)
             , m_parent(parent)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             if (!m_modelAsset.GetId().IsValid())
             {
@@ -507,7 +507,7 @@ namespace AZ
         //! AssetBus::Handler overrides...
         void MeshDataInstance::MeshLoader::OnAssetReady(Data::Asset<Data::AssetData> asset)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             Data::Asset<RPI::ModelAsset> modelAsset = asset;
 
             // Assign the fully loaded asset back to the mesh handle to not only hold asset id, but the actual data as well.
@@ -579,7 +579,7 @@ namespace AZ
 
         void MeshDataInstance::Init(Data::Instance<RPI::Model> model)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             m_model = model;
             const size_t modelLodCount = m_model->GetLodCount();
@@ -611,7 +611,7 @@ namespace AZ
 
         void MeshDataInstance::BuildDrawPacketList(size_t modelLodIndex)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             RPI::ModelLod& modelLod = *m_model->GetLods()[modelLodIndex];
             const size_t meshCount = modelLod.GetMeshes().size();
@@ -985,7 +985,7 @@ namespace AZ
 
         void MeshDataInstance::UpdateDrawPackets(bool forceUpdate /*= false*/)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             for (auto& drawPacketList : m_drawPacketListsByLod)
             {
                 for (auto& drawPacket : drawPacketList)
@@ -1000,7 +1000,7 @@ namespace AZ
 
         void MeshDataInstance::BuildCullable()
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_Assert(m_cullableNeedsRebuild, "This function only needs to be called if the cullable to be rebuilt");
             AZ_Assert(m_model, "The model has not finished loading yet");
 
@@ -1079,7 +1079,7 @@ namespace AZ
 
         void MeshDataInstance::UpdateCullBounds(const TransformServiceFeatureProcessor* transformService)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_Assert(m_cullBoundsNeedsUpdate, "This function only needs to be called if the culling bounds need to be rebuilt");
             AZ_Assert(m_model, "The model has not finished loading yet");
 
diff --git a/Gems/Atom/Feature/Common/Code/Source/ReflectionProbe/ReflectionProbeFeatureProcessor.cpp b/Gems/Atom/Feature/Common/Code/Source/ReflectionProbe/ReflectionProbeFeatureProcessor.cpp
index c0e25e3da9..341d1a0274 100644
--- a/Gems/Atom/Feature/Common/Code/Source/ReflectionProbe/ReflectionProbeFeatureProcessor.cpp
+++ b/Gems/Atom/Feature/Common/Code/Source/ReflectionProbe/ReflectionProbeFeatureProcessor.cpp
@@ -154,7 +154,7 @@ namespace AZ
 
         void ReflectionProbeFeatureProcessor::Simulate([[maybe_unused]] const FeatureProcessor::SimulatePacket& packet)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_ATOM_PROFILE_FUNCTION("ReflectionProbe", "ReflectionProbeFeatureProcessor: Simulate");
 
             // update pipeline states
@@ -193,7 +193,7 @@ namespace AZ
             // if the volumes changed we need to re-sort the probe list
             if (m_probeSortRequired)
             {
-                AZ_PROFILE_SCOPE(Debug::ProfileCategory::AzRender, "Sort reflection probes");
+                AZ_PROFILE_SCOPE(AzRender, "Sort reflection probes");
                 AZ_ATOM_PROFILE_FUNCTION("ReflectionProbe", "ReflectionProbeFeatureProcessor: Sort reflection probes");
 
                 // sort the probes by descending inner volume size, so the smallest volumes are rendered last
diff --git a/Gems/Atom/Feature/Common/Code/Source/SkinnedMesh/SkinnedMeshFeatureProcessor.cpp b/Gems/Atom/Feature/Common/Code/Source/SkinnedMesh/SkinnedMeshFeatureProcessor.cpp
index ebe52cdafe..0aa72bf2ca 100644
--- a/Gems/Atom/Feature/Common/Code/Source/SkinnedMesh/SkinnedMeshFeatureProcessor.cpp
+++ b/Gems/Atom/Feature/Common/Code/Source/SkinnedMesh/SkinnedMeshFeatureProcessor.cpp
@@ -69,13 +69,13 @@ namespace AZ
 
         void SkinnedMeshFeatureProcessor::Render(const FeatureProcessor::RenderPacket& packet)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_ATOM_PROFILE_FUNCTION("SkinnedMesh", "SkinnedMeshFeatureProcessor: Render");
 
 #if 0 //[GFX_TODO][ATOM-13564] Temporarily disable skinning culling until we figure out how to hook up visibility & lod selection with skinning:
             //Setup the culling workgroup (it will be re-used for each view)
             {
-                AZ_PROFILE_SCOPE(Debug::ProfileCategory::AzRender, "set up skinned culling workgroup");
+                AZ_PROFILE_SCOPE(AzRender, "set up skinned culling workgroup");
                 azsnprintf(m_workgroup.m_name, AZ_ARRAY_SIZE(m_workgroup.m_name), "SkinnedMeshFP workgroup");
                 m_workgroup.m_drawListMask.reset();
                 m_workgroup.m_cullPackets.clear();
@@ -118,11 +118,11 @@ namespace AZ
                     Job* processWorkgroupJob = AZ::CreateJobFunction(
                         [this, cullingSystem, viewPtr](AZ::Job& thisJob)
                         {
-                            AZ_PROFILE_SCOPE_DYNAMIC(Debug::ProfileCategory::AzRender, "skinningMeshFP processWorkgroupJob - View: %s", viewPtr->GetName().GetCStr());
+                            AZ_PROFILE_SCOPE(AzRender, "skinningMeshFP processWorkgroupJob - View: %s", viewPtr->GetName().GetCStr());
 
                             auto dispatchSkinningComputeProgramsCallback = [this](AZStd::shared_ptr<RPI::CullingBatchResults> results) -> void
                             {
-                                AZ_PROFILE_SCOPE(Debug::ProfileCategory::AzRender, "dispatchSkinningComputePrograms");
+                                AZ_PROFILE_SCOPE(AzRender, "dispatchSkinningComputePrograms");
 
                                 //the [1][1] element of a projection matrix stores cot(FovY/2) (equal to 2*nearPlaneDistance/nearPlaneHeight),
                                 //which is used to determine the (vertical) projected size in screen space            
diff --git a/Gems/Atom/Feature/Common/Code/Source/SkinnedMesh/SkinnedMeshInputBuffers.cpp b/Gems/Atom/Feature/Common/Code/Source/SkinnedMesh/SkinnedMeshInputBuffers.cpp
index af427eb554..58c8b3a4a3 100644
--- a/Gems/Atom/Feature/Common/Code/Source/SkinnedMesh/SkinnedMeshInputBuffers.cpp
+++ b/Gems/Atom/Feature/Common/Code/Source/SkinnedMesh/SkinnedMeshInputBuffers.cpp
@@ -532,7 +532,7 @@ namespace AZ
             //            lod0 Positions[^                         ^]             lod0Normals[^                         ^]   lod1Positions[^     ^]     lod1Normals[^     ^]
             // lod0 subMesh0+1 Positions[^             ^^          ^] lod0 subMesh0+1 Normals[^             ^^          ^]  lod1 sm0+1 pos[^  ^^ ^] lod1 sm0+1 norm[^  ^^ ^]
 
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZStd::intrusive_ptr<SkinnedMeshInstance> instance = aznew SkinnedMeshInstance;
 
             // Each model gets a unique, random ID, so if the same source model is used for multiple instances, multiple target models will be created.
diff --git a/Gems/Atom/RHI/Code/Source/RHI/AsyncWorkQueue.cpp b/Gems/Atom/RHI/Code/Source/RHI/AsyncWorkQueue.cpp
index d74ce558cd..a32301276e 100644
--- a/Gems/Atom/RHI/Code/Source/RHI/AsyncWorkQueue.cpp
+++ b/Gems/Atom/RHI/Code/Source/RHI/AsyncWorkQueue.cpp
@@ -7,6 +7,8 @@
  */
 #include <Atom/RHI/AsyncWorkQueue.h>
 
+#include <AzCore/Debug/Profiler.h>
+
 namespace AZ
 {
     namespace RHI
@@ -124,7 +126,7 @@ namespace AZ
                 return;
             }
 
-            AZ_PROFILE_FUNCTION_IDLE(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             AZStd::unique_lock<AZStd::mutex> lock(m_waitWorkItemMutex);
             m_waitWorkItemCondition.wait(lock, [&]() {return HasFinishedWork(workHandle); });
diff --git a/Gems/Atom/RHI/Code/Source/RHI/CommandQueue.cpp b/Gems/Atom/RHI/Code/Source/RHI/CommandQueue.cpp
index ae6a645440..2474967dab 100644
--- a/Gems/Atom/RHI/Code/Source/RHI/CommandQueue.cpp
+++ b/Gems/Atom/RHI/Code/Source/RHI/CommandQueue.cpp
@@ -22,7 +22,7 @@ namespace AZ
 
         ResultCode CommandQueue::Init(Device& device, const CommandQueueDescriptor& descriptor)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
 #if defined (AZ_RHI_ENABLE_VALIDATION)
             if (IsInitialized())
@@ -116,7 +116,7 @@ namespace AZ
 
                 //run a command
                 {
-                    AZ_PROFILE_SCOPE(Debug::ProfileCategory::AzRender, "RHI::CommandQueue - Execute Command");
+                    AZ_PROFILE_SCOPE(AzRender, "RHI::CommandQueue - Execute Command");
                     command(GetNativeQueue());
                 }
             }
diff --git a/Gems/Atom/RHI/Code/Source/RHI/Fence.cpp b/Gems/Atom/RHI/Code/Source/RHI/Fence.cpp
index 838beb0863..868d2e3317 100644
--- a/Gems/Atom/RHI/Code/Source/RHI/Fence.cpp
+++ b/Gems/Atom/RHI/Code/Source/RHI/Fence.cpp
@@ -81,7 +81,7 @@ namespace AZ
                 return ResultCode::InvalidOperation;
             }
 
-            AZ_PROFILE_FUNCTION_IDLE(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             WaitOnCpuInternal();
             return ResultCode::Success;
         }
diff --git a/Gems/Atom/RHI/Code/Source/RHI/FrameScheduler.cpp b/Gems/Atom/RHI/Code/Source/RHI/FrameScheduler.cpp
index 795ab591eb..0793c1ffd0 100644
--- a/Gems/Atom/RHI/Code/Source/RHI/FrameScheduler.cpp
+++ b/Gems/Atom/RHI/Code/Source/RHI/FrameScheduler.cpp
@@ -137,7 +137,7 @@ namespace AZ
 
         ResultCode FrameScheduler::ImportScopeProducer(ScopeProducer& scopeProducer)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             if (!ValidateIsProcessing())
             {
@@ -216,7 +216,7 @@ namespace AZ
 
         void FrameScheduler::PrepareProducers()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_ATOM_PROFILE_FUNCTION("RHI", "FrameScheduler: PrepareProducers");
 
             for (ScopeProducer* scopeProducer : m_scopeProducers)
@@ -237,7 +237,7 @@ namespace AZ
 
         void FrameScheduler::CompileProducers()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_ATOM_PROFILE_FUNCTION("RHI", "FrameScheduler: CompileProducers");
 
             for (ScopeProducer* scopeProducer : m_scopeProducers)
@@ -249,12 +249,12 @@ namespace AZ
 
         void FrameScheduler::CompileShaderResourceGroups()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_ATOM_PROFILE_FUNCTION("RHI", "FrameScheduler: CompileShaderResourceGroups");
 
             // Execute all queued resource invalidations, which will mark SRG's for compilation.
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzRender, "Invalidate Resources");
+                AZ_PROFILE_SCOPE(AzRender, "Invalidate Resources");
                 ResourceInvalidateBus::ExecuteQueuedEvents();
             }
 
@@ -322,7 +322,7 @@ namespace AZ
 
         void FrameScheduler::BuildRayTracingShaderTables()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_ATOM_PROFILE_FUNCTION("RHI", "FrameScheduler: BuildRayTracingShaderTables");
 
             for (auto rayTracingShaderTable : m_rayTracingShaderTablesToBuild)
@@ -341,7 +341,7 @@ namespace AZ
 
         ResultCode FrameScheduler::BeginFrame()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_ATOM_PROFILE_FUNCTION("RHI", "FrameScheduler: BeginFrame");
 
             if (!ValidateIsInitialized())
@@ -376,7 +376,7 @@ namespace AZ
 
         ResultCode FrameScheduler::EndFrame()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_ATOM_PROFILE_FUNCTION("RHI", "FrameScheduler: EndFrame");
 
             if (Validation::IsEnabled())
@@ -417,13 +417,13 @@ namespace AZ
 
         void FrameScheduler::ExecuteContextInternal(FrameGraphExecuteGroup& group, uint32_t index)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             FrameGraphExecuteContext* executeContext = group.BeginContext(index);
 
             {
                 ScopeProducer* scopeProducer = FindScopeProducer(executeContext->GetScopeId());
 
-                AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzRender, "ScopeProducer: %s", scopeProducer->GetScopeId().GetCStr());
+                AZ_PROFILE_SCOPE(AzRender, "ScopeProducer: %s", scopeProducer->GetScopeId().GetCStr());
                 scopeProducer->BuildCommandList(*executeContext);
             }
 
@@ -432,7 +432,7 @@ namespace AZ
 
         void FrameScheduler::ExecuteGroupInternal(AZ::Job* parentJob, uint32_t groupIndex)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_ATOM_PROFILE_FUNCTION("RHI", "FrameScheduler: ExecuteGroupInternal");
 
             FrameGraphExecuteGroup* executeGroup = m_frameGraphExecuter->BeginGroup(groupIndex);
@@ -475,7 +475,7 @@ namespace AZ
 
         void FrameScheduler::Execute(JobPolicy overrideJobPolicy)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_ATOM_PROFILE_FUNCTION("RHI", "FrameScheduler: Execute");
 
             const uint32_t groupCount = m_frameGraphExecuter->GetGroupCount();
diff --git a/Gems/Atom/RHI/Code/Source/RHI/PipelineStateCache.cpp b/Gems/Atom/RHI/Code/Source/RHI/PipelineStateCache.cpp
index 0210d941dc..69eee86108 100644
--- a/Gems/Atom/RHI/Code/Source/RHI/PipelineStateCache.cpp
+++ b/Gems/Atom/RHI/Code/Source/RHI/PipelineStateCache.cpp
@@ -272,7 +272,7 @@ namespace AZ
 
         const PipelineState* PipelineStateCache::AcquirePipelineState(PipelineLibraryHandle handle, const PipelineStateDescriptor& descriptor)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             if (handle.IsNull())
             {
diff --git a/Gems/Atom/RHI/Code/Source/RHI/RHISystem.cpp b/Gems/Atom/RHI/Code/Source/RHI/RHISystem.cpp
index 49244f776f..5e08696ec2 100644
--- a/Gems/Atom/RHI/Code/Source/RHI/RHISystem.cpp
+++ b/Gems/Atom/RHI/Code/Source/RHI/RHISystem.cpp
@@ -209,11 +209,11 @@ namespace AZ
 
         void RHISystem::FrameUpdate(FrameGraphCallback frameGraphCallback)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_ATOM_PROFILE_FUNCTION("RHI", "RHISystem: FrameUpdate");
 
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzRender, "main per-frame work");
+                AZ_PROFILE_SCOPE(AzRender, "main per-frame work");
                 m_frameScheduler.BeginFrame();
 
                 frameGraphCallback(m_frameScheduler);
diff --git a/Gems/Atom/RHI/DX12/Code/Source/RHI/AsyncUploadQueue.cpp b/Gems/Atom/RHI/DX12/Code/Source/RHI/AsyncUploadQueue.cpp
index 70c6aa0b7c..81e52d6d3f 100644
--- a/Gems/Atom/RHI/DX12/Code/Source/RHI/AsyncUploadQueue.cpp
+++ b/Gems/Atom/RHI/DX12/Code/Source/RHI/AsyncUploadQueue.cpp
@@ -152,21 +152,21 @@ namespace AZ
 
             m_copyQueue->QueueCommand([=](void* commandQueue)
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzRender, "Upload Buffer");
+                AZ_PROFILE_SCOPE(AzRender, "Upload Buffer");
                 size_t pendingByteOffset = 0;
                 size_t pendingByteCount = byteCount;
                 ID3D12CommandQueue* dx12CommandQueue = static_cast<ID3D12CommandQueue*>(commandQueue);
 
                 while (pendingByteCount > 0)
                 {
-                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzRender, "Upload Buffer Chunk");
+                    AZ_PROFILE_SCOPE(AzRender, "Upload Buffer Chunk");
 
                     FramePacket* framePacket = BeginFramePacket();
 
                     const size_t bytesToCopy = AZStd::min(pendingByteCount, m_descriptor.m_stagingSizeInBytes);
 
                     {
-                        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzRender, "Copy CPU buffer");
+                        AZ_PROFILE_SCOPE(AzRender, "Copy CPU buffer");
                         memcpy(framePacket->m_stagingResourceData, sourceData + pendingByteOffset, bytesToCopy);
                     }
 
@@ -196,7 +196,7 @@ namespace AZ
 
         AsyncUploadQueue::FramePacket* AsyncUploadQueue::BeginFramePacket()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_Assert(!m_recordingFrame, "The previous frame packet isn't ended");
 
             FramePacket* framePacket = &m_framePackets[m_frameIndex];
@@ -212,7 +212,7 @@ namespace AZ
 
         void AsyncUploadQueue::EndFramePacket(ID3D12CommandQueue* commandQueue)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_Assert(m_recordingFrame, "The frame packet wasn't started. You need to call StartFramePacket first.");
 
             AssertSuccess(m_commandList->Close());
@@ -229,7 +229,7 @@ namespace AZ
         // [GFX TODO][ATOM-4205] Stage/Upload 3D streaming images more efficiently.
         uint64_t AsyncUploadQueue::QueueUpload(const RHI::StreamingImageExpandRequest& request, uint32_t residentMip)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             uint64_t fenceValue = m_uploadFence.Increment();
 
@@ -243,7 +243,7 @@ namespace AZ
 
             m_copyQueue->QueueCommand([=](void* commandQueue)
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzRender, "Upload Image");
+                AZ_PROFILE_SCOPE(AzRender, "Upload Image");
                 ID3D12CommandQueue* dx12CommandQueue = static_cast<ID3D12CommandQueue*>(commandQueue);
                 FramePacket* framePacket = BeginFramePacket();
 
@@ -314,7 +314,7 @@ namespace AZ
 
                                 // Copy subresource data to staging memory.
                                 {
-                                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzRender, "Copy CPU image");
+                                    AZ_PROFILE_SCOPE(AzRender, "Copy CPU image");
 
                                     uint8_t* stagingDataStart = framePacket->m_stagingResourceData + framePacket->m_dataOffset;
                                     const uint8_t* subresourceSliceDataStart = static_cast<const uint8_t*>(subresource.m_data) + (depth * subresourceSlicePitch);
@@ -385,7 +385,7 @@ namespace AZ
 
                                     // Copy subresource data to staging memory
                                     {
-                                        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzRender, "Copy CPU image");
+                                        AZ_PROFILE_SCOPE(AzRender, "Copy CPU image");
                                         for (uint32_t row = startRow; row < endRow; row++)
                                         {
                                             uint8_t* stagingDataStart = framePacket->m_stagingResourceData + framePacket->m_dataOffset;
@@ -476,7 +476,7 @@ namespace AZ
 
         void AsyncUploadQueue::WaitForUpload(uint64_t fenceValue)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             if (!IsUploadFinished(fenceValue))
             {
@@ -490,7 +490,7 @@ namespace AZ
 
         void AsyncUploadQueue::ProcessCallbacks(uint64_t fenceValue)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZStd::lock_guard<AZStd::mutex> lock(m_callbackMutex);
             while (m_callbacks.size() > 0 && m_callbacks.front().second <= fenceValue)
             {
@@ -504,7 +504,7 @@ namespace AZ
         {
             m_copyQueue->QueueCommand([=](void* commandQueue)
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzRender, "QueueTileMapping");
+                AZ_PROFILE_SCOPE(AzRender, "QueueTileMapping");
 
                 ID3D12CommandQueue* dx12CommandQueue = static_cast<ID3D12CommandQueue*>(commandQueue);
                 const uint32_t tileCount = request.m_sourceRegionSize.NumTiles;
diff --git a/Gems/Atom/RHI/DX12/Code/Source/RHI/CommandListBase.cpp b/Gems/Atom/RHI/DX12/Code/Source/RHI/CommandListBase.cpp
index 7aa9f5391a..a8ae753294 100644
--- a/Gems/Atom/RHI/DX12/Code/Source/RHI/CommandListBase.cpp
+++ b/Gems/Atom/RHI/DX12/Code/Source/RHI/CommandListBase.cpp
@@ -33,7 +33,7 @@ namespace AZ
 
         void CommandListBase::Reset(ID3D12CommandAllocator* commandAllocator)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);  
+            AZ_PROFILE_FUNCTION(AzRender);  
             AZ_Assert(m_queuedBarriers.empty(), "Unflushed barriers in command list.");
 
             m_commandList->Reset(commandAllocator, nullptr);
@@ -95,7 +95,7 @@ namespace AZ
         {
             if (m_queuedBarriers.size())
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRenderDetailed);
+                AZ_PROFILE_FUNCTION(AzRenderDetailed);
 
                 m_commandList->ResourceBarrier((UINT)m_queuedBarriers.size(), m_queuedBarriers.data());
                 m_queuedBarriers.clear();
diff --git a/Gems/Atom/RHI/DX12/Code/Source/RHI/CommandListBase.h b/Gems/Atom/RHI/DX12/Code/Source/RHI/CommandListBase.h
index 5337228614..5f3e4dce1e 100644
--- a/Gems/Atom/RHI/DX12/Code/Source/RHI/CommandListBase.h
+++ b/Gems/Atom/RHI/DX12/Code/Source/RHI/CommandListBase.h
@@ -7,11 +7,15 @@
  */
 #pragma once
 
+// NOTE: We are careful to include platform headers *before* we include AzCore/Debug/Profiler.h to ensure that d3d12 symbols
+// are defined prior to the inclusion of the pix3 runtime.
+#include <RHI/DX12.h>
+
 #include <Atom/RHI/DeviceObject.h>
 #include <Atom/RHI.Reflect/AttachmentEnums.h>
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/std/containers/vector.h>
 #include <AzCore/std/containers/unordered_map.h>
-#include <RHI/DX12.h>
 
 namespace AZ
 {
diff --git a/Gems/Atom/RHI/DX12/Code/Source/RHI/CommandQueue.cpp b/Gems/Atom/RHI/DX12/Code/Source/RHI/CommandQueue.cpp
index 9de706cbe1..b73228e717 100644
--- a/Gems/Atom/RHI/DX12/Code/Source/RHI/CommandQueue.cpp
+++ b/Gems/Atom/RHI/DX12/Code/Source/RHI/CommandQueue.cpp
@@ -110,7 +110,7 @@ namespace AZ
         {
             QueueCommand([this, &fence](void* commandQueue)
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzRender, "SignalFence");
+                AZ_PROFILE_SCOPE(AzRender, "SignalFence");
                 ID3D12CommandQueue* dx12CommandQueue = static_cast<ID3D12CommandQueue*>(commandQueue);
                 dx12CommandQueue->Signal(fence.Get(), fence.GetPendingValue());
             });
@@ -138,7 +138,7 @@ namespace AZ
 
             QueueCommand([=](void* commandQueue)
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzRender, "ExecuteWork");
+                AZ_PROFILE_SCOPE(AzRender, "ExecuteWork");
                 AZ_PROFILE_RHI_VARIABLE(m_lastExecuteDuration);
 
                 static const uint32_t CommandListCountMax = 128;
@@ -195,7 +195,7 @@ namespace AZ
 
         void CommandQueue::UpdateTileMappings(CommandList& commandList)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             for (const CommandList::TileMapRequest& request : commandList.GetTileMapRequests())
             {
                 const uint32_t tileCount = request.m_sourceRegionSize.NumTiles;
@@ -229,7 +229,7 @@ namespace AZ
         
         void CommandQueue::WaitForIdle()
         {
-            AZ_PROFILE_FUNCTION_IDLE(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             Fence fence;
             fence.Init(m_device.get(), RHI::FenceState::Reset);
diff --git a/Gems/Atom/RHI/DX12/Code/Source/RHI/CommandQueueContext.cpp b/Gems/Atom/RHI/DX12/Code/Source/RHI/CommandQueueContext.cpp
index 1c5fd6fa05..f35f66f3e8 100644
--- a/Gems/Atom/RHI/DX12/Code/Source/RHI/CommandQueueContext.cpp
+++ b/Gems/Atom/RHI/DX12/Code/Source/RHI/CommandQueueContext.cpp
@@ -101,7 +101,7 @@ namespace AZ
 
         void CommandQueueContext::WaitForIdle()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             for (uint32_t hardwareQueueIdx = 0; hardwareQueueIdx < RHI::HardwareQueueClassCount; ++hardwareQueueIdx)
             {
                 if (m_commandQueues[hardwareQueueIdx])
@@ -113,10 +113,10 @@ namespace AZ
 
         void CommandQueueContext::Begin()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzRender, "Clearing Command Queue Timers");
+                AZ_PROFILE_SCOPE(AzRender, "Clearing Command Queue Timers");
                 for (const RHI::Ptr<CommandQueue>& commandQueue : m_commandQueues)
                 {
                     commandQueue->ClearTimers();
@@ -131,7 +131,7 @@ namespace AZ
 
         void CommandQueueContext::End()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_ATOM_PROFILE_FUNCTION("DX12", "CommandQueueContext: End");
 
             QueueGpuSignals(m_frameFences[m_currentFrameIndex]);
@@ -145,7 +145,7 @@ namespace AZ
             m_currentFrameIndex = (m_currentFrameIndex + 1) % aznumeric_cast<uint32_t>(m_frameFences.size());
 
             {
-                AZ_PROFILE_SCOPE_IDLE(AZ::Debug::ProfileCategory::AzRender, "Wait and Reset Fence");
+                AZ_PROFILE_SCOPE(AzRender, "Wait and Reset Fence");
                 AZ_ATOM_PROFILE_TIME_GROUP_REGION("DX12", "CommandQueueContext: Wait on Fences");
 
                 FenceEvent event("FrameFence");
diff --git a/Gems/Atom/RHI/DX12/Code/Source/RHI/Fence.cpp b/Gems/Atom/RHI/DX12/Code/Source/RHI/Fence.cpp
index f61aa3f67f..6244089d93 100644
--- a/Gems/Atom/RHI/DX12/Code/Source/RHI/Fence.cpp
+++ b/Gems/Atom/RHI/DX12/Code/Source/RHI/Fence.cpp
@@ -60,7 +60,7 @@ namespace AZ
         {
             if (fenceValue > GetCompletedValue())
             {
-                AZ_PROFILE_SCOPE_IDLE_DYNAMIC(AZ::Debug::ProfileCategory::AzRender, "Fence Wait: %s", fenceEvent.GetName());
+                AZ_PROFILE_SCOPE(AzRender, "Fence Wait: %s", fenceEvent.GetName());
                 m_fence->SetEventOnCompletion(fenceValue, fenceEvent.m_EventHandle);
                 WaitForSingleObject(fenceEvent.m_EventHandle, INFINITE);
             }
diff --git a/Gems/Atom/RHI/DX12/Code/Source/RHI/Fence.h b/Gems/Atom/RHI/DX12/Code/Source/RHI/Fence.h
index 064efe5722..133b8aa664 100644
--- a/Gems/Atom/RHI/DX12/Code/Source/RHI/Fence.h
+++ b/Gems/Atom/RHI/DX12/Code/Source/RHI/Fence.h
@@ -7,12 +7,13 @@
  */
 #pragma once
 
+#include <RHI/DX12.h>
+
 #include <Atom/RHI/Fence.h>
 #include <Atom/RHI/Scope.h>
 #include <AzCore/Memory/PoolAllocator.h>
 #include <AzCore/std/containers/array.h>
 #include <AzCore/std/smart_ptr/intrusive_ptr.h>
-#include <RHI/DX12.h>
 
 namespace AZ
 {
diff --git a/Gems/Atom/RHI/DX12/Code/Source/RHI/StreamingImagePool.cpp b/Gems/Atom/RHI/DX12/Code/Source/RHI/StreamingImagePool.cpp
index 6f35bb32ae..c00dcced58 100644
--- a/Gems/Atom/RHI/DX12/Code/Source/RHI/StreamingImagePool.cpp
+++ b/Gems/Atom/RHI/DX12/Code/Source/RHI/StreamingImagePool.cpp
@@ -144,7 +144,7 @@ namespace AZ
 
 #ifdef AZ_RHI_USE_TILED_RESOURCES
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzRender, "StreamImagePool::CreateHeap");
+                AZ_PROFILE_SCOPE(AzRender, "StreamImagePool::CreateHeap");
 
                 CD3DX12_HEAP_DESC heapDesc(descriptor.m_budgetInBytes, D3D12_HEAP_TYPE_DEFAULT, 0, D3D12_HEAP_FLAG_DENY_BUFFERS | D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES);
 
diff --git a/Gems/Atom/RHI/Metal/Code/Source/RHI/CommandQueue.cpp b/Gems/Atom/RHI/Metal/Code/Source/RHI/CommandQueue.cpp
index 5db3cfb0d3..4bde063d63 100644
--- a/Gems/Atom/RHI/Metal/Code/Source/RHI/CommandQueue.cpp
+++ b/Gems/Atom/RHI/Metal/Code/Source/RHI/CommandQueue.cpp
@@ -114,7 +114,7 @@ namespace AZ
                      //Autoreleasepool is to ensure that the driver is not leaking memory related to the command buffer and encoder
                      @autoreleasepool
                      {
-                         AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzRender, "ExecuteWork");
+                         AZ_PROFILE_SCOPE(AzRender, "ExecuteWork");
                          AZ_PROFILE_RHI_VARIABLE(m_lastExecuteDuration);
                          
                          if (request.m_signalFenceValue > 0)
diff --git a/Gems/Atom/RHI/Metal/Code/Source/RHI/CommandQueueContext.cpp b/Gems/Atom/RHI/Metal/Code/Source/RHI/CommandQueueContext.cpp
index 814610b4d5..f0ec98be89 100644
--- a/Gems/Atom/RHI/Metal/Code/Source/RHI/CommandQueueContext.cpp
+++ b/Gems/Atom/RHI/Metal/Code/Source/RHI/CommandQueueContext.cpp
@@ -79,7 +79,7 @@ namespace AZ
 
         void CommandQueueContext::End()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             
             QueueGpuSignals(m_frameFences[m_currentFrameIndex]);
             for (uint32_t hardwareQueueIdx = 0; hardwareQueueIdx < RHI::HardwareQueueClassCount; ++hardwareQueueIdx)
@@ -91,7 +91,7 @@ namespace AZ
             m_currentFrameIndex = (m_currentFrameIndex + 1) % aznumeric_cast<uint32_t>(m_frameFences.size());
 
             {
-                AZ_PROFILE_SCOPE_IDLE(AZ::Debug::ProfileCategory::AzRender, "Wait and Reset Fence");
+                AZ_PROFILE_SCOPE(AzRender, "Wait and Reset Fence");
                 AZ_ATOM_PROFILE_TIME_GROUP_REGION("RHI", "CommandQueueContext: Wait on Fences");
 
                 //Synchronize the CPU with the GPU by waiting on the fence until signalled by the GPU. CPU can only go upto
diff --git a/Gems/Atom/RHI/Vulkan/Code/Source/RHI/AsyncUploadQueue.cpp b/Gems/Atom/RHI/Vulkan/Code/Source/RHI/AsyncUploadQueue.cpp
index 18b5d83ed3..12e14f6134 100644
--- a/Gems/Atom/RHI/Vulkan/Code/Source/RHI/AsyncUploadQueue.cpp
+++ b/Gems/Atom/RHI/Vulkan/Code/Source/RHI/AsyncUploadQueue.cpp
@@ -96,7 +96,7 @@ namespace AZ
             uploadFence->Init(device, RHI::FenceState::Reset);
             CommandQueue::Command command = [=, &device](void* queue)
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzRender, "Upload Buffer");
+                AZ_PROFILE_SCOPE(AzRender, "Upload Buffer");
                 size_t pendingByteOffset = 0;
                 size_t pendingByteCount = byteCount;
                 FramePacket* framePacket = nullptr;
@@ -110,7 +110,7 @@ namespace AZ
 
                 while (pendingByteCount > 0)
                 {
-                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzRender, "Upload Buffer Chunk");
+                    AZ_PROFILE_SCOPE(AzRender, "Upload Buffer Chunk");
 
                     framePacket = BeginFramePacket(vulkanQueue);
                     const size_t bytesToCopy = AZStd::min(pendingByteCount, m_descriptor.m_stagingSizeInBytes);
@@ -181,7 +181,7 @@ namespace AZ
 
             CommandQueue::Command command = [=, &device](void* queue)
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzRender, "Upload Image");
+                AZ_PROFILE_SCOPE(AzRender, "Upload Image");
 
                 Queue* vulkanQueue = static_cast<Queue*>(queue);
                 FramePacket* framePacket = BeginFramePacket(vulkanQueue);
@@ -257,7 +257,7 @@ namespace AZ
 
                                 // Copy subresource data to staging memory.
                                 {
-                                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzRender, "Copy CPU image");
+                                    AZ_PROFILE_SCOPE(AzRender, "Copy CPU image");
                                     uint8_t* stagingDataStart = reinterpret_cast<uint8_t*>(framePacket->m_stagingBuffer->GetBufferMemoryView()->Map(RHI::HostMemoryAccess::Write)) + framePacket->m_dataOffset;
                                     for (uint32_t row = 0; row < subresourceLayout.m_rowCount; ++row)
                                     {
@@ -332,7 +332,7 @@ namespace AZ
 
                                     // Copy subresource data to staging memory.
                                     {
-                                        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzRender, "Copy CPU image");
+                                        AZ_PROFILE_SCOPE(AzRender, "Copy CPU image");
 
                                         uint8_t* stagingDataStart = reinterpret_cast<uint8_t*>(framePacket->m_stagingBuffer->GetBufferMemoryView()->Map(RHI::HostMemoryAccess::Write));
                                         stagingDataStart += framePacket->m_dataOffset;
@@ -458,7 +458,7 @@ namespace AZ
 
         AsyncUploadQueue::FramePacket* AsyncUploadQueue::BeginFramePacket(Queue* queue)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_Assert(!m_recordingFrame, "The previous frame packet isn't ended.");
             auto& device = static_cast<Device&>(GetDevice());
 
@@ -478,7 +478,7 @@ namespace AZ
 
         void AsyncUploadQueue::EndFramePacket(Queue* queue, Semaphore* semaphoreToSignal /*=nullptr*/)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_Assert(m_recordingFrame, "The frame packet wasn't started. You need to call StartFramePacket first.");
 
             m_commandList->EndCommandBuffer();
@@ -644,7 +644,7 @@ namespace AZ
 
         void AsyncUploadQueue::ProcessCallback(const RHI::AsyncWorkHandle& handle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZStd::unique_lock<AZStd::mutex> lock(m_callbackListMutex);
             auto findIter = m_callbackList.find(handle);
             if (findIter != m_callbackList.end())
diff --git a/Gems/Atom/RHI/Vulkan/Code/Source/RHI/CommandQueue.cpp b/Gems/Atom/RHI/Vulkan/Code/Source/RHI/CommandQueue.cpp
index 84b4964235..6929b63ac4 100644
--- a/Gems/Atom/RHI/Vulkan/Code/Source/RHI/CommandQueue.cpp
+++ b/Gems/Atom/RHI/Vulkan/Code/Source/RHI/CommandQueue.cpp
@@ -54,7 +54,7 @@ namespace AZ
             const ExecuteWorkRequest& request = static_cast<const ExecuteWorkRequest&>(rhiRequest);
             QueueCommand([=](void* queue) 
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzRender, "ExecuteWork");
+                AZ_PROFILE_SCOPE(AzRender, "ExecuteWork");
                 AZ_PROFILE_RHI_VARIABLE(m_lastExecuteDuration);
 
                 Queue* vulkanQueue = static_cast<Queue*>(queue);
diff --git a/Gems/Atom/RHI/Vulkan/Code/Source/RHI/CommandQueueContext.cpp b/Gems/Atom/RHI/Vulkan/Code/Source/RHI/CommandQueueContext.cpp
index 8635e8edcf..9457a765fa 100644
--- a/Gems/Atom/RHI/Vulkan/Code/Source/RHI/CommandQueueContext.cpp
+++ b/Gems/Atom/RHI/Vulkan/Code/Source/RHI/CommandQueueContext.cpp
@@ -42,7 +42,7 @@ namespace AZ
 
         void CommandQueueContext::End()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             for (auto& commandQueue : m_commandQueues)
             {
@@ -54,7 +54,7 @@ namespace AZ
             m_currentFrameIndex = (m_currentFrameIndex + 1) % GetFrameCount();
 
             {
-                AZ_PROFILE_SCOPE_IDLE(AZ::Debug::ProfileCategory::AzRender, "Wait on Fences");
+                AZ_PROFILE_SCOPE(AzRender, "Wait on Fences");
                 AZ_ATOM_PROFILE_FUNCTION("RHI", "CommandQueueContext: Wait on Fences");
 
                 FencesPerQueue& nextFences = m_frameFences[m_currentFrameIndex];
@@ -79,7 +79,7 @@ namespace AZ
 
         void CommandQueueContext::WaitForIdle()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             for (auto& commandQueue : m_commandQueues)
             {
                 commandQueue->WaitForIdle();
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Public/Culling.cpp b/Gems/Atom/RPI/Code/Source/RPI.Public/Culling.cpp
index c630fe0e5d..841607404a 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Public/Culling.cpp
+++ b/Gems/Atom/RPI/Code/Source/RPI.Public/Culling.cpp
@@ -299,7 +299,7 @@ namespace AZ
             //work function
             void Process() override
             {
-                AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+                AZ_PROFILE_FUNCTION(AzRender);
 
                 const View::UsageFlags viewFlags = m_jobData->m_view->GetUsageFlags();
                 const RHI::DrawListMask drawListMask = m_jobData->m_view->GetDrawListMask();
@@ -312,7 +312,7 @@ namespace AZ
                     bool nodeIsContainedInFrustum = ShapeIntersection::Contains(m_jobData->m_frustum, nodeData.m_bounds);
 
 #ifdef AZ_CULL_PROFILE_VERBOSE
-                    AZ_PROFILE_SCOPE_DYNAMIC(Debug::ProfileCategory::AzRender, "process node (view: %s, skip fine cull: %d",
+                    AZ_PROFILE_SCOPE(AzRender, "process node (view: %s, skip fine cull: %d",
                         m_view->GetName().GetCStr(), nodeIsContainedInFrustum ? 1 : 0);
 #endif
 
@@ -385,7 +385,7 @@ namespace AZ
 
                     if (m_jobData->m_debugCtx->m_debugDraw && (m_jobData->m_view->GetName() == m_jobData->m_debugCtx->m_currentViewSelectionName))
                     {
-                        AZ_PROFILE_SCOPE(Debug::ProfileCategory::AzRender, "debug draw culling");
+                        AZ_PROFILE_SCOPE(AzRender, "debug draw culling");
 
                         AuxGeomDrawPtr auxGeomPtr = AuxGeomFeatureProcessorInterface::GetDrawQueueForScene(m_jobData->m_scene);
                         if (auxGeomPtr)
@@ -507,7 +507,7 @@ namespace AZ
 
         void CullingScene::ProcessCullables(const Scene& scene, View& view, AZ::Job& parentJob)
         {
-            AZ_PROFILE_SCOPE_DYNAMIC(Debug::ProfileCategory::AzRender, "CullingScene::ProcessCullables() - %s", view.GetName().GetCStr());
+            AZ_PROFILE_SCOPE(AzRender, "CullingScene::ProcessCullables() - %s", view.GetName().GetCStr());
 
             const Matrix4x4& worldToClip = view.GetWorldToClipMatrix();
             Frustum frustum = Frustum::CreateFromMatrixColumnMajor(worldToClip);
@@ -598,7 +598,7 @@ namespace AZ
 
             auto nodeVisitorLambda = [this, jobData, &parentJob, &frustum, &worklist](const AzFramework::IVisibilityScene::NodeData& nodeData) -> void
             {
-                AZ_PROFILE_SCOPE(Debug::ProfileCategory::AzRender, "nodeVisitorLambda()");
+                AZ_PROFILE_SCOPE(AzRender, "nodeVisitorLambda()");
                 AZ_Assert(nodeData.m_entries.size() > 0, "should not get called with 0 entries");
                 AZ_Assert(worklist.size() < worklist.capacity(), "we should always have room to push a node on the queue");
 
@@ -645,7 +645,7 @@ namespace AZ
         uint32_t AddLodDataToView(const Vector3& pos, const Cullable::LodData& lodData, RPI::View& view)
         {
 #ifdef AZ_CULL_PROFILE_DETAILED
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 #endif
 
             const Matrix4x4& viewToClip = view.GetViewToClipMatrix();
@@ -663,7 +663,7 @@ namespace AZ
             auto addLodToDrawPacket = [&](const Cullable::LodData::Lod& lod)
             {
 #ifdef AZ_CULL_PROFILE_VERBOSE
-                AZ_PROFILE_SCOPE_DYNAMIC(Debug::ProfileCategory::AzRender, "add draw packets: %zu", lod.m_drawPackets.size());
+                AZ_PROFILE_SCOPE(AzRender, "add draw packets: %zu", lod.m_drawPackets.size());
 #endif
                 numVisibleDrawPackets += static_cast<uint32_t>(lod.m_drawPackets.size());   //don't want to pay the cost of aznumeric_cast<> here so using static_cast<> instead
                 for (const RHI::DrawPacket* drawPacket : lod.m_drawPackets)
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Public/Material/Material.cpp b/Gems/Atom/RPI/Code/Source/RPI.Public/Material/Material.cpp
index 4f941463eb..1de6776d9c 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Public/Material/Material.cpp
+++ b/Gems/Atom/RPI/Code/Source/RPI.Public/Material/Material.cpp
@@ -310,7 +310,7 @@ namespace AZ
 
             if (NeedsCompile() && CanCompile())
             {
-                AZ_PROFILE_EVENT_BEGIN(Debug::ProfileCategory::AzRender, "Material::Compile() Processing Functors");
+                AZ_PROFILE_BEGIN(AzRender, "Material::Compile() Processing Functors");
                 for (const Ptr<MaterialFunctor>& functor : m_materialAsset->GetMaterialFunctors())
                 {
                     if (functor)
@@ -339,7 +339,7 @@ namespace AZ
                         AZ_Error(s_debugTraceName, false, "Material functor is null.");
                     }
                 }
-                AZ_PROFILE_EVENT_END(Debug::ProfileCategory::AzRender);
+                AZ_PROFILE_END();
 
                 m_propertyDirtyFlags.reset();
 
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Public/MeshDrawPacket.cpp b/Gems/Atom/RPI/Code/Source/RPI.Public/MeshDrawPacket.cpp
index 5762720913..7fd7133cee 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Public/MeshDrawPacket.cpp
+++ b/Gems/Atom/RPI/Code/Source/RPI.Public/MeshDrawPacket.cpp
@@ -124,7 +124,7 @@ namespace AZ
 
         bool MeshDrawPacket::DoUpdate(const Scene& parentScene)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             const ModelLod::Mesh& mesh = m_modelLod->GetMeshes()[m_modelLodMeshIndex];
 
             if (!m_material)
@@ -155,7 +155,7 @@ namespace AZ
 
             auto appendShader = [&](const ShaderCollection::Item& shaderItem)
             {
-                AZ_PROFILE_SCOPE(Debug::ProfileCategory::AzRender, "appendShader()");
+                AZ_PROFILE_SCOPE(AzRender, "appendShader()");
 
                 // Skip the shader item without creating the shader instance
                 // if the mesh is not going to be rendered based on the draw tag
@@ -256,7 +256,7 @@ namespace AZ
                 Data::Instance<ShaderResourceGroup> drawSrg;
                 if (drawSrgLayout)
                 {
-                    AZ_PROFILE_SCOPE(Debug::ProfileCategory::AzRender, "create drawSrg");
+                    AZ_PROFILE_SCOPE(AzRender, "create drawSrg");
                     // If the DrawSrg exists we must create and bind it, otherwise the CommandList will fail validation for SRG being null
                     drawSrg = RPI::ShaderResourceGroup::Create(shader->GetAsset(), shader->GetSupervariantIndex(), drawSrgLayout->GetName());
 
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Public/Model/Model.cpp b/Gems/Atom/RPI/Code/Source/RPI.Public/Model/Model.cpp
index 32fe297c57..0cbcdbf5f4 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Public/Model/Model.cpp
+++ b/Gems/Atom/RPI/Code/Source/RPI.Public/Model/Model.cpp
@@ -42,7 +42,7 @@ namespace AZ
 
         Data::Instance<Model> Model::CreateInternal(const Data::Asset<ModelAsset>& modelAsset)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             Data::Instance<Model> model = aznew Model();
             const RHI::ResultCode resultCode = model->Init(modelAsset);
 
@@ -56,7 +56,7 @@ namespace AZ
 
         RHI::ResultCode Model::Init(const Data::Asset<ModelAsset>& modelAsset)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             m_lods.resize(modelAsset->GetLodAssets().size());
 
@@ -107,7 +107,7 @@ namespace AZ
         {
             if (m_isUploadPending)
             {
-                AZ_PROFILE_SCOPE_STALL_DYNAMIC(Debug::ProfileCategory::AzRender, "Model::WaitForUpload - %s", GetDatabaseName());
+                AZ_PROFILE_SCOPE(AzRender, "Model::WaitForUpload - %s", GetDatabaseName());
                 for (const Data::Instance<ModelLod>& lod : m_lods)
                 {
                     lod->WaitForUpload();
@@ -128,7 +128,7 @@ namespace AZ
 
         bool Model::LocalRayIntersection(const AZ::Vector3& rayStart, const AZ::Vector3& rayDir, float& distanceNormalized, AZ::Vector3& normal) const
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             
             if (!GetModelAsset())
             {
@@ -171,7 +171,7 @@ namespace AZ
             float& distanceNormalized,
             AZ::Vector3& normal) const
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             const AZ::Vector3 clampedScale = nonUniformScale.GetMax(AZ::Vector3(AZ::MinTransformScale));
 
             const AZ::Transform inverseTM = modelTransform.GetInverse();
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Public/Model/ModelLod.cpp b/Gems/Atom/RPI/Code/Source/RPI.Public/Model/ModelLod.cpp
index dc39200a65..cfe0d08270 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Public/Model/ModelLod.cpp
+++ b/Gems/Atom/RPI/Code/Source/RPI.Public/Model/ModelLod.cpp
@@ -264,7 +264,7 @@ namespace AZ
             const MaterialModelUvOverrideMap& materialModelUvMap,
             const MaterialUvNameMap& materialUvNameMap) const
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             streamBufferViewsOut.clear();
 
@@ -366,7 +366,7 @@ namespace AZ
             const MaterialModelUvOverrideMap& materialModelUvMap,
             const MaterialUvNameMap& materialUvNameMap) const
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             const Mesh& mesh = m_meshes[meshIndex];
 
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Public/Model/ModelLodUtils.cpp b/Gems/Atom/RPI/Code/Source/RPI.Public/Model/ModelLodUtils.cpp
index dc5c1f5c4d..0fe035dd85 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Public/Model/ModelLodUtils.cpp
+++ b/Gems/Atom/RPI/Code/Source/RPI.Public/Model/ModelLodUtils.cpp
@@ -27,7 +27,7 @@ namespace AZ
 
             ModelLodIndex SelectLod(const View* view, const Vector3& position, const Model& model, ModelLodIndex lodOverride)
             {
-                AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+                AZ_PROFILE_FUNCTION(AzRender);
                 ModelLodIndex lodIndex;
                 if (model.GetLodCount() == 1)
                 {
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Public/Pass/PassSystem.cpp b/Gems/Atom/RPI/Code/Source/RPI.Public/Pass/PassSystem.cpp
index d73521763f..4cf952ee01 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Public/Pass/PassSystem.cpp
+++ b/Gems/Atom/RPI/Code/Source/RPI.Public/Pass/PassSystem.cpp
@@ -189,7 +189,7 @@ namespace AZ
         void PassSystem::BuildPasses()
         {
             m_state = PassSystemState::BuildingPasses;
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_ATOM_PROFILE_FUNCTION("RPI", "PassSystem: BuildPassAttachments");
 
             m_passHierarchyChanged = m_passHierarchyChanged || !m_buildPassList.empty();
@@ -239,7 +239,7 @@ namespace AZ
         void PassSystem::InitializePasses()
         {
             m_state = PassSystemState::InitializingPasses;
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_ATOM_PROFILE_FUNCTION("RPI", "PassSystem: BuildPassAttachments");
 
             m_passHierarchyChanged = m_passHierarchyChanged || !m_initializePassList.empty();
@@ -286,7 +286,7 @@ namespace AZ
                     return;
                 }
 
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+                AZ_PROFILE_FUNCTION(AzRender);
 
                 PassValidationResults validationResults;
                 m_rootPass->Validate(validationResults);
@@ -307,7 +307,7 @@ namespace AZ
 
         void PassSystem::FrameUpdate(RHI::FrameGraphBuilder& frameGraphBuilder)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_ATOM_PROFILE_FUNCTION("RPI", "PassSystem: FrameUpdate");
 
             ResetFrameStatistics();
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Public/Pass/RasterPass.cpp b/Gems/Atom/RPI/Code/Source/RPI.Public/Pass/RasterPass.cpp
index ce02e1c570..d37002eb6b 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Public/Pass/RasterPass.cpp
+++ b/Gems/Atom/RPI/Code/Source/RPI.Public/Pass/RasterPass.cpp
@@ -216,7 +216,7 @@ namespace AZ
 
         void RasterPass::CompileResources(const RHI::FrameGraphCompileContext& context)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             if (m_shaderResourceGroup == nullptr)
             {
@@ -230,7 +230,7 @@ namespace AZ
 
         void RasterPass::BuildCommandListInternal(const RHI::FrameGraphExecuteContext& context)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             RHI::CommandList* commandList = context.GetCommandList();
 
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Public/RPISystem.cpp b/Gems/Atom/RPI/Code/Source/RPI.Public/RPISystem.cpp
index d2a32784ce..efc050eb68 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Public/RPISystem.cpp
+++ b/Gems/Atom/RPI/Code/Source/RPI.Public/RPISystem.cpp
@@ -270,7 +270,7 @@ namespace AZ
                 return;
             }
 
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             AZ_ATOM_PROFILE_FUNCTION("RPI", "RPISystem: RenderTick");
 
             // Query system update is to increment the frame count
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Public/RenderPipeline.cpp b/Gems/Atom/RPI/Code/Source/RPI.Public/RenderPipeline.cpp
index 89f7da11e3..a552ac86f2 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Public/RenderPipeline.cpp
+++ b/Gems/Atom/RPI/Code/Source/RPI.Public/RenderPipeline.cpp
@@ -377,7 +377,7 @@ namespace AZ
 
         void RenderPipeline::OnStartFrame(const TickTimeInfo& tick)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             m_lastRenderStartTime = tick.m_currentGameTime;
 
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Public/Scene.cpp b/Gems/Atom/RPI/Code/Source/RPI.Public/Scene.cpp
index 02a03ee853..4d3dcba36e 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Public/Scene.cpp
+++ b/Gems/Atom/RPI/Code/Source/RPI.Public/Scene.cpp
@@ -399,7 +399,7 @@ namespace AZ
             AZ_ATOM_PROFILE_FUNCTION("RPI", "Scene: PrepareRender");
 
             {
-                AZ_PROFILE_SCOPE(Debug::ProfileCategory::AzRender, "WaitForSimulationCompletion");
+                AZ_PROFILE_SCOPE(AzRender, "WaitForSimulationCompletion");
                 AZ_ATOM_PROFILE_TIME_GROUP_REGION("RPI", "WaitForSimulationCompletion");
                 WaitAndCleanCompletionJob(m_simulationCompletion);
             }
@@ -407,7 +407,7 @@ namespace AZ
             SceneNotificationBus::Event(GetId(), &SceneNotification::OnBeginPrepareRender);
 
             {
-                AZ_PROFILE_SCOPE(Debug::ProfileCategory::AzRender, "m_srgCallback");
+                AZ_PROFILE_SCOPE(AzRender, "m_srgCallback");
                 AZ_ATOM_PROFILE_TIME_GROUP_REGION("RPI", "ShaderResourceGroupCallback: SrgCallback");
                 // Set values for scene srg
                 if (m_srg && m_srgCallback)
@@ -483,7 +483,7 @@ namespace AZ
             }
 
             {
-                AZ_PROFILE_SCOPE(Debug::ProfileCategory::AzRender, "CollectDrawPackets");                
+                AZ_PROFILE_SCOPE(AzRender, "CollectDrawPackets");                
                 AZ_ATOM_PROFILE_TIME_GROUP_REGION("RPI", "CollectDrawPackets");
                 AZ::JobCompletion* collectDrawPacketsCompletion = aznew AZ::JobCompletion();
 
@@ -533,7 +533,7 @@ namespace AZ
             }
 
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzRender, "FinalizeDrawLists");
+                AZ_PROFILE_BEGIN(AzRender, "FinalizeDrawLists");
                 AZ_ATOM_PROFILE_TIME_GROUP_REGION("RPI", "FinalizeDrawLists");
                 if (jobPolicy == RHI::JobPolicy::Serial)
                 {
@@ -556,7 +556,7 @@ namespace AZ
                         finalizeDrawListsJob->SetDependent(finalizeDrawListsCompletion);
                         finalizeDrawListsJob->Start();
                     }
-                    AZ_PROFILE_EVENT_END(Debug::ProfileCategory::AzRender);
+                    AZ_PROFILE_END();
                     WaitAndCleanCompletionJob(finalizeDrawListsCompletion);
                 }
             }
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Public/Shader/Metrics/ShaderMetricsSystem.cpp b/Gems/Atom/RPI/Code/Source/RPI.Public/Shader/Metrics/ShaderMetricsSystem.cpp
index d0d76e62de..c0f0e20714 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Public/Shader/Metrics/ShaderMetricsSystem.cpp
+++ b/Gems/Atom/RPI/Code/Source/RPI.Public/Shader/Metrics/ShaderMetricsSystem.cpp
@@ -113,7 +113,7 @@ namespace AZ
                 return;
             }
 
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             AZStd::lock_guard<AZStd::mutex> lock(m_metricsMutex);
 
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Public/Shader/Shader.cpp b/Gems/Atom/RPI/Code/Source/RPI.Public/Shader/Shader.cpp
index ff277c5cad..f6dcd02804 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Public/Shader/Shader.cpp
+++ b/Gems/Atom/RPI/Code/Source/RPI.Public/Shader/Shader.cpp
@@ -297,7 +297,7 @@ namespace AZ
 
         const ShaderVariant& Shader::GetVariant(const ShaderVariantId& shaderVariantId)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             Data::Asset<ShaderVariantAsset> shaderVariantAsset = m_asset->GetVariant(shaderVariantId, m_supervariantIndex);
             if (!shaderVariantAsset || shaderVariantAsset->IsRootVariant())
             {
@@ -314,14 +314,14 @@ namespace AZ
 
         ShaderVariantSearchResult Shader::FindVariantStableId(const ShaderVariantId& shaderVariantId) const
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             ShaderVariantSearchResult variantSearchResult = m_asset->FindVariantStableId(shaderVariantId);
             return variantSearchResult;
         }
 
         const ShaderVariant& Shader::GetVariant(ShaderVariantStableId shaderVariantStableId)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             if (!shaderVariantStableId.IsValid() || shaderVariantStableId == ShaderAsset::RootShaderVariantStableId)
             {
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Public/View.cpp b/Gems/Atom/RPI/Code/Source/RPI.Public/View.cpp
index 1937afc240..f1f25e3303 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Public/View.cpp
+++ b/Gems/Atom/RPI/Code/Source/RPI.Public/View.cpp
@@ -237,7 +237,7 @@ namespace AZ
 
         void View::FinalizeDrawLists()
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
             m_drawListContext.FinalizeLists();
             SortFinalizedDrawLists();
         }
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Reflect/Model/ModelAsset.cpp b/Gems/Atom/RPI/Code/Source/RPI.Reflect/Model/ModelAsset.cpp
index 275b056514..e1da50d2fb 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Reflect/Model/ModelAsset.cpp
+++ b/Gems/Atom/RPI/Code/Source/RPI.Reflect/Model/ModelAsset.cpp
@@ -96,7 +96,7 @@ namespace AZ
             const AZ::Vector3& rayStart, const AZ::Vector3& rayDir, bool allowBruteForce,
             float& distanceNormalized, AZ::Vector3& normal) const
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             if (!m_modelTriangleCount)
             {
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Reflect/Shader/ShaderAsset.cpp b/Gems/Atom/RPI/Code/Source/RPI.Reflect/Shader/ShaderAsset.cpp
index f2d82918ea..adeb564675 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Reflect/Shader/ShaderAsset.cpp
+++ b/Gems/Atom/RPI/Code/Source/RPI.Reflect/Shader/ShaderAsset.cpp
@@ -172,7 +172,7 @@ namespace AZ
         Data::Asset<ShaderVariantAsset> ShaderAsset::GetVariant(
             const ShaderVariantId& shaderVariantId, SupervariantIndex supervariantIndex)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             auto variantFinder = AZ::Interface<IShaderVariantFinder>::Get();
             AZ_Assert(variantFinder, "The IShaderVariantFinder doesn't exist");
@@ -189,7 +189,7 @@ namespace AZ
 
         ShaderVariantSearchResult ShaderAsset::FindVariantStableId(const ShaderVariantId& shaderVariantId)
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             uint32_t dynamicOptionCount = aznumeric_cast<uint32_t>(GetShaderOptionGroupLayout()->GetShaderOptions().size());
             ShaderVariantSearchResult variantSearchResult{RootShaderVariantStableId,  dynamicOptionCount };
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Reflect/Shader/ShaderVariantTreeAsset.cpp b/Gems/Atom/RPI/Code/Source/RPI.Reflect/Shader/ShaderVariantTreeAsset.cpp
index 46873dc62d..bd0cad9f4d 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Reflect/Shader/ShaderVariantTreeAsset.cpp
+++ b/Gems/Atom/RPI/Code/Source/RPI.Reflect/Shader/ShaderVariantTreeAsset.cpp
@@ -72,7 +72,7 @@ namespace AZ
 
         ShaderVariantSearchResult ShaderVariantTreeAsset::FindVariantStableId(const ShaderOptionGroupLayout* shaderOptionGroupLayout, const ShaderVariantId& shaderVariantId) const
         {
-            AZ_PROFILE_FUNCTION(Debug::ProfileCategory::AzRender);
+            AZ_PROFILE_FUNCTION(AzRender);
 
             struct NodeToVisit
             {
diff --git a/Gems/Atom/Utils/Code/Include/Atom/Utils/StableDynamicArray.h b/Gems/Atom/Utils/Code/Include/Atom/Utils/StableDynamicArray.h
index 454a6d4086..e73f641b96 100644
--- a/Gems/Atom/Utils/Code/Include/Atom/Utils/StableDynamicArray.h
+++ b/Gems/Atom/Utils/Code/Include/Atom/Utils/StableDynamicArray.h
@@ -130,6 +130,7 @@ namespace AZ
     template<typename T, size_t ElementsPerPage, class Allocator>
     struct StableDynamicArray<T, ElementsPerPage, Allocator>::Page
     {
+        static constexpr size_t PageSize = ElementsPerPage * sizeof(T);
         static constexpr size_t InvalidPage = -1;
         static constexpr uint64_t FullBits = 0xFFFFFFFFFFFFFFFFull;
         static constexpr size_t NumUint64_t = ElementsPerPage / 64;
diff --git a/Gems/AtomLyIntegration/CommonFeatures/Code/Source/SurfaceData/SurfaceDataMeshComponent.cpp b/Gems/AtomLyIntegration/CommonFeatures/Code/Source/SurfaceData/SurfaceDataMeshComponent.cpp
index 3c5d45abc2..be4d5186c8 100644
--- a/Gems/AtomLyIntegration/CommonFeatures/Code/Source/SurfaceData/SurfaceDataMeshComponent.cpp
+++ b/Gems/AtomLyIntegration/CommonFeatures/Code/Source/SurfaceData/SurfaceDataMeshComponent.cpp
@@ -147,7 +147,7 @@ namespace SurfaceData
 
     bool SurfaceDataMeshComponent::DoRayTrace(const AZ::Vector3& inPosition, AZ::Vector3& outPosition, AZ::Vector3& outNormal) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::lock_guard<decltype(m_cacheMutex)> lock(m_cacheMutex);
 
@@ -233,7 +233,7 @@ namespace SurfaceData
 
     void SurfaceDataMeshComponent::UpdateMeshData()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         bool meshValidBeforeUpdate = false;
         bool meshValidAfterUpdate = false;
diff --git a/Gems/AudioEngineWwise/Code/Source/Engine/AudioSystemImpl_wwise.cpp b/Gems/AudioEngineWwise/Code/Source/Engine/AudioSystemImpl_wwise.cpp
index e4933728d4..738806a912 100644
--- a/Gems/AudioEngineWwise/Code/Source/Engine/AudioSystemImpl_wwise.cpp
+++ b/Gems/AudioEngineWwise/Code/Source/Engine/AudioSystemImpl_wwise.cpp
@@ -374,7 +374,7 @@ namespace Audio
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     void CAudioSystemImpl_wwise::Update([[maybe_unused]] const float updateIntervalMS)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Audio);
+        AZ_PROFILE_FUNCTION(Audio);
 
         if (AK::SoundEngine::IsInitialized())
         {
@@ -731,7 +731,7 @@ namespace Audio
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     EAudioRequestStatus CAudioSystemImpl_wwise::UpdateAudioObject(IATLAudioObjectData* const audioObjectData)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Audio);
+        AZ_PROFILE_FUNCTION(Audio);
 
         EAudioRequestStatus result = eARS_FAILURE;
 
diff --git a/Gems/AudioEngineWwise/Code/Source/Engine/FileIOHandler_wwise.cpp b/Gems/AudioEngineWwise/Code/Source/Engine/FileIOHandler_wwise.cpp
index 30084565d6..bfb1254e52 100644
--- a/Gems/AudioEngineWwise/Code/Source/Engine/FileIOHandler_wwise.cpp
+++ b/Gems/AudioEngineWwise/Code/Source/Engine/FileIOHandler_wwise.cpp
@@ -265,7 +265,7 @@ namespace Audio
 
         auto callback = [&transferInfo](AZ::IO::FileRequestHandle request)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Audio);
+            AZ_PROFILE_FUNCTION(Audio);
             AZ::IO::IStreamerTypes::RequestStatus status = AZ::Interface<AZ::IO::IStreamer>::Get()->GetRequestStatus(request);
             switch (status)
             {
diff --git a/Gems/AudioSystem/Code/Source/Engine/ATL.cpp b/Gems/AudioSystem/Code/Source/Engine/ATL.cpp
index e6700ea610..ff56300b85 100644
--- a/Gems/AudioSystem/Code/Source/Engine/ATL.cpp
+++ b/Gems/AudioSystem/Code/Source/Engine/ATL.cpp
@@ -148,7 +148,7 @@ namespace Audio
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     void CAudioTranslationLayer::Update()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Audio);
+        AZ_PROFILE_FUNCTION(Audio);
 
         auto current = AZStd::chrono::system_clock::now();
         m_elapsedTime = AZStd::chrono::duration_cast<duration_ms>(current - m_lastUpdateTime);
@@ -2016,7 +2016,7 @@ namespace Audio
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     void CAudioTranslationLayer::DrawAudioSystemDebugInfo()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Audio);
+        AZ_PROFILE_FUNCTION(Audio);
 
         // ToDo: Update to work with Atom? LYN-3677
         /*if (CVars::s_debugDrawOptions.GetRawFlags() != 0)
diff --git a/Gems/AudioSystem/Code/Source/Engine/ATLComponents.cpp b/Gems/AudioSystem/Code/Source/Engine/ATLComponents.cpp
index 7010012e87..91340ca9bb 100644
--- a/Gems/AudioSystem/Code/Source/Engine/ATLComponents.cpp
+++ b/Gems/AudioSystem/Code/Source/Engine/ATLComponents.cpp
@@ -9,6 +9,7 @@
 
 #include <ATLComponents.h>
 
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/IO/FileIO.h>
 #include <AzCore/std/functional.h>
 #include <AzCore/std/string/string_view.h>
@@ -304,7 +305,7 @@ namespace Audio
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     void CAudioObjectManager::Update(const float fUpdateIntervalMS, const SATLWorldPosition& rListenerPosition)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Audio);
+        AZ_PROFILE_FUNCTION(Audio);
 
         m_fTimeSinceLastVelocityUpdateMS += fUpdateIntervalMS;
         const bool bUpdateVelocity = m_fTimeSinceLastVelocityUpdateMS > s_fVelocityUpdateIntervalMS;
@@ -317,7 +318,7 @@ namespace Audio
 
             if (pObject->HasActiveEvents())
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Audio, "Inner Per-Object CAudioObjectManager::Update");
+                AZ_PROFILE_SCOPE(Audio, "Inner Per-Object CAudioObjectManager::Update");
 
                 pObject->Update(fUpdateIntervalMS, rListenerPosition);
 
@@ -936,7 +937,7 @@ namespace Audio
     void CAudioEventListenerManager::NotifyListener(const SAudioRequestInfo* const pResultInfo)
     {
         // This should always be on the main thread!
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Audio);
+        AZ_PROFILE_FUNCTION(Audio);
 
         auto found = AZStd::find_if(m_cListeners.begin(), m_cListeners.end(),
             [pResultInfo](const SAudioEventListener& currentListener)
diff --git a/Gems/AudioSystem/Code/Source/Engine/ATLUtils.h b/Gems/AudioSystem/Code/Source/Engine/ATLUtils.h
index c1bb8251f9..97266e95c3 100644
--- a/Gems/AudioSystem/Code/Source/Engine/ATLUtils.h
+++ b/Gems/AudioSystem/Code/Source/Engine/ATLUtils.h
@@ -16,6 +16,7 @@
 #include <AzCore/std/string/string_view.h>
 #include <AzCore/std/typetraits/is_integral.h>
 #include <AzCore/std/typetraits/is_unsigned.h>
+#include <AzCore/std/time.h>
 
 #define ATL_FLOAT_EPSILON (1.0e-6)
 
diff --git a/Gems/AudioSystem/Code/Source/Engine/AudioSystem.cpp b/Gems/AudioSystem/Code/Source/Engine/AudioSystem.cpp
index 30d815cbec..43ab47266a 100644
--- a/Gems/AudioSystem/Code/Source/Engine/AudioSystem.cpp
+++ b/Gems/AudioSystem/Code/Source/Engine/AudioSystem.cpp
@@ -115,7 +115,7 @@ namespace Audio
     void CAudioSystem::PushRequestBlocking(const SAudioRequest& audioRequestData)
     {
         // Main Thread!
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Audio);
+        AZ_PROFILE_FUNCTION(Audio);
 
         CAudioRequestInternal request(audioRequestData);
 
@@ -201,7 +201,7 @@ namespace Audio
     void CAudioSystem::InternalUpdate()
     {
         // Audio Thread!
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Audio);
+        AZ_PROFILE_FUNCTION(Audio);
 
         auto startUpdateTime = AZStd::chrono::system_clock::now();        // stamp the start time
 
@@ -225,7 +225,7 @@ namespace Audio
     #if !defined(AUDIO_RELEASE)
         #if defined(PROVIDE_GETNAME_SUPPORT)
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Audio, "Sync Debug Name Changes");
+            AZ_PROFILE_SCOPE(Audio, "Sync Debug Name Changes");
             AZStd::lock_guard<AZStd::mutex> lock(m_debugNameStoreMutex);
             m_debugNameStore.SyncChanges(m_oATL.GetDebugStore());
         }
@@ -238,7 +238,7 @@ namespace Audio
             auto elapsedUpdateTime = AZStd::chrono::duration_cast<duration_ms>(endUpdateTime - startUpdateTime);
             if (elapsedUpdateTime < m_targetUpdatePeriod)
             {
-                AZ_PROFILE_SCOPE_IDLE(AZ::Debug::ProfileCategory::Audio, "Wait Remaining Time in Update Period");
+                AZ_PROFILE_SCOPE(Audio, "Wait Remaining Time in Update Period");
                 m_processingEvent.try_acquire_for(m_targetUpdatePeriod - elapsedUpdateTime);
             }
         }
@@ -596,7 +596,7 @@ namespace Audio
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     void CAudioSystem::ProcessRequestBlocking(CAudioRequestInternal& request)
     {
-        AZ_PROFILE_FUNCTION_STALL(AZ::Debug::ProfileCategory::Audio);
+        AZ_PROFILE_FUNCTION(Audio);
 
         if (m_oATL.CanProcessRequests())
         {
@@ -616,7 +616,7 @@ namespace Audio
     void CAudioSystem::ProcessRequestThreadSafe(CAudioRequestInternal request)
     {
         // Audio Thread!
-        AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::Audio, "Thread-Safe Request: %s", request.ToString().c_str());
+        AZ_PROFILE_SCOPE(Audio, "Thread-Safe Request: %s", request.ToString().c_str());
 
         if (m_oATL.CanProcessRequests())
         {
@@ -641,7 +641,7 @@ namespace Audio
     {
         // Todo: This should handle request priority, use request priority as bus Address and process in priority order.
 
-        AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::Audio, "Normal Request: %s", request.ToString().c_str());
+        AZ_PROFILE_SCOPE(Audio, "Normal Request: %s", request.ToString().c_str());
 
         AZ_Assert(g_mainThreadId != AZStd::this_thread::get_id(), "AudioSystem::ProcessRequestByPriority - called from Main thread!");
 
@@ -672,7 +672,7 @@ namespace Audio
         {
             if (!(request.nInternalInfoFlags & eARIF_WAITING_FOR_REMOVAL))
             {
-                AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::Audio, "Blocking Request: %s", request.ToString().c_str());
+                AZ_PROFILE_SCOPE(Audio, "Blocking Request: %s", request.ToString().c_str());
 
                 if (request.eStatus == eARS_NONE)
                 {
diff --git a/Gems/AudioSystem/Code/Source/Engine/FileCacheManager.cpp b/Gems/AudioSystem/Code/Source/Engine/FileCacheManager.cpp
index f1a360fd7d..791c86eba8 100644
--- a/Gems/AudioSystem/Code/Source/Engine/FileCacheManager.cpp
+++ b/Gems/AudioSystem/Code/Source/Engine/FileCacheManager.cpp
@@ -9,6 +9,7 @@
 
 #include <FileCacheManager.h>
 
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/IO/FileIO.h>
 #include <AzCore/IO/IStreamer.h>
 #include <AzCore/IO/Path/Path.h>
@@ -61,7 +62,7 @@ namespace Audio
     ///////////////////////////////////////////////////////////////////////////////////////////////
     void CFileCacheManager::Update()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Audio);
+        AZ_PROFILE_FUNCTION(Audio);
 
         AudioFileCacheManagerNotficationBus::ExecuteQueuedEvents();
         UpdatePreloadRequestsStatus();
@@ -538,7 +539,7 @@ namespace Audio
     bool CFileCacheManager::FinishCachingFileInternal(CATLAudioFileEntry* const audioFileEntry, [[maybe_unused]] AZ::IO::SizeType bytesRead,
         AZ::IO::IStreamerTypes::RequestStatus requestState)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Audio);
+        AZ_PROFILE_FUNCTION(Audio);
 
         bool success = false;
         audioFileEntry->m_asyncStreamRequest.reset();
@@ -640,7 +641,7 @@ namespace Audio
     ///////////////////////////////////////////////////////////////////////////////////////////////
     bool CFileCacheManager::AllocateMemoryBlockInternal(CATLAudioFileEntry* const audioFileEntry)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Audio);
+        AZ_PROFILE_FUNCTION(Audio);
 
         // Must not have valid memory yet.
         AZ_Assert(!audioFileEntry->m_memoryBlock, "FileCacheManager AllocateMemoryBlockInternal - Memory appears to be set already!");
@@ -786,7 +787,7 @@ namespace Audio
         const bool overrideUseCount /* = false */,
         const size_t useCount /* = 0 */)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Audio);
+        AZ_PROFILE_FUNCTION(Audio);
 
         bool success = false;
 
@@ -842,7 +843,7 @@ namespace Audio
                         audioFileEntry->m_asyncStreamRequest,
                         [this](AZ::IO::FileRequestHandle request)
                         {
-                            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Audio);
+                            AZ_PROFILE_FUNCTION(Audio);
                             AudioFileCacheManagerNotficationBus::QueueBroadcast(
                                 &AudioFileCacheManagerNotficationBus::Events::FinishAsyncStreamRequest,
                                 request);
diff --git a/Gems/Blast/Code/Source/Components/BlastFamilyComponent.cpp b/Gems/Blast/Code/Source/Components/BlastFamilyComponent.cpp
index d05a679733..ec6e7bbbb9 100644
--- a/Gems/Blast/Code/Source/Components/BlastFamilyComponent.cpp
+++ b/Gems/Blast/Code/Source/Components/BlastFamilyComponent.cpp
@@ -187,7 +187,7 @@ namespace Blast
 
     void BlastFamilyComponent::Activate()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::System);
+        AZ_PROFILE_FUNCTION(System);
 
         AZ_Assert(m_blastAsset.GetId().IsValid(), "BlastFamilyComponent created with invalid blast asset.");
 
@@ -199,7 +199,7 @@ namespace Blast
 
     void BlastFamilyComponent::Deactivate()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::System);
+        AZ_PROFILE_FUNCTION(System);
 
         // cleanup collision handlers
         for (auto& itr : m_collisionHandlers)
@@ -216,7 +216,7 @@ namespace Blast
 
     void BlastFamilyComponent::Spawn()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         if (!m_blastAsset.IsReady())
         {
@@ -297,7 +297,7 @@ namespace Blast
 
     void BlastFamilyComponent::Despawn()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         m_isSpawned = false;
 
@@ -414,7 +414,7 @@ namespace Blast
 
     void BlastFamilyComponent::OnCollisionBegin(const AzPhysics::CollisionEvent& collisionEvent)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         for (const auto* body : {collisionEvent.m_body1, collisionEvent.m_body2})
         {
@@ -493,7 +493,7 @@ namespace Blast
 
     void BlastFamilyComponent::ApplyStressDamage()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         if (m_solver)
         {
@@ -589,7 +589,7 @@ namespace Blast
     // Update positions of entities with render meshes corresponding to their right dynamic bodies.
     void BlastFamilyComponent::SyncMeshes()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         if (m_actorRenderManager)
         {
diff --git a/Gems/Blast/Code/Source/Components/BlastSystemComponent.cpp b/Gems/Blast/Code/Source/Components/BlastSystemComponent.cpp
index bee94ed116..711d3a0087 100644
--- a/Gems/Blast/Code/Source/Components/BlastSystemComponent.cpp
+++ b/Gems/Blast/Code/Source/Components/BlastSystemComponent.cpp
@@ -112,7 +112,7 @@ namespace Blast
 
     void BlastSystemComponent::Activate()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::System);
+        AZ_PROFILE_FUNCTION(System);
         auto blastAssetHandler = aznew BlastAssetHandler();
         blastAssetHandler->Register();
         m_assetHandlers.emplace_back(blastAssetHandler);
@@ -141,7 +141,7 @@ namespace Blast
 
     void BlastSystemComponent::Deactivate()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::System);
+        AZ_PROFILE_FUNCTION(System);
         CrySystemEventBus::Handler::BusDisconnect();
         AZ::TickBus::Handler::BusDisconnect();
         BlastSystemRequestBus::Handler::BusDisconnect();
@@ -185,7 +185,7 @@ namespace Blast
 
     void BlastSystemComponent::OnTick([[maybe_unused]] float deltaTime, [[maybe_unused]] AZ::ScriptTimePoint time)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         AZ::JobCompletion jobCompletion;
 
@@ -226,18 +226,18 @@ namespace Blast
 
         for (auto& group : m_groups)
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Physics, "ExtGroupTaskManager::process");
+            AZ_PROFILE_SCOPE(Physics, "ExtGroupTaskManager::process");
             group.m_extGroupTaskManager->process();
         }
         for (auto& group : m_groups)
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Physics, "ExtGroupTaskManager::wait");
+            AZ_PROFILE_SCOPE(Physics, "ExtGroupTaskManager::wait");
             group.m_extGroupTaskManager->wait();
         }
 
         // Clean up damage descriptions and program params now that groups have run.
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Physics, "BlastSystemComponent::OnTick::Cleanup");
+            AZ_PROFILE_SCOPE(Physics, "BlastSystemComponent::OnTick::Cleanup");
             m_radialDamageDescs.clear();
             m_capsuleDamageDescs.clear();
             m_shearDamageDescs.clear();
@@ -248,7 +248,7 @@ namespace Blast
 
         if (gEnv && m_debugRenderMode)
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Physics, "BlastSystemComponent::OnTick::DebugRender");
+            AZ_PROFILE_SCOPE(Physics, "BlastSystemComponent::OnTick::DebugRender");
             DebugRenderBuffer buffer;
             BlastFamilyComponentRequestBus::Broadcast(
                 &BlastFamilyComponentRequests::FillDebugRenderBuffer, buffer, m_debugRenderMode);
@@ -428,12 +428,12 @@ namespace Blast
 
     void BlastSystemComponent::AZBlastProfilerCallback::zoneStart(const char* eventName)
     {
-        AZ_PROFILE_EVENT_BEGIN(AZ::Debug::ProfileCategory::Physics, eventName);
+        AZ_PROFILE_BEGIN(Physics, eventName);
     }
 
     void BlastSystemComponent::AZBlastProfilerCallback::zoneEnd()
     {
-        AZ_PROFILE_EVENT_END(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_END();
     }
 
     static void CmdToggleBlastDebugVisualization(IConsoleCmdArgs* args)
diff --git a/Gems/Blast/Code/Source/Editor/EditorBlastFamilyComponent.cpp b/Gems/Blast/Code/Source/Editor/EditorBlastFamilyComponent.cpp
index 58f28ed32a..3bc6da4297 100644
--- a/Gems/Blast/Code/Source/Editor/EditorBlastFamilyComponent.cpp
+++ b/Gems/Blast/Code/Source/Editor/EditorBlastFamilyComponent.cpp
@@ -96,7 +96,7 @@ namespace Blast
 
     void EditorBlastFamilyComponent::Activate()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::System);
+        AZ_PROFILE_FUNCTION(System);
 
         if (m_blastAsset.GetId().IsValid())
         {
@@ -107,7 +107,7 @@ namespace Blast
 
     void EditorBlastFamilyComponent::Deactivate()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::System);
+        AZ_PROFILE_FUNCTION(System);
 
         AZ::Data::AssetBus::MultiHandler::BusDisconnect();
     }
diff --git a/Gems/Blast/Code/Source/Editor/EditorBlastMeshDataComponent.cpp b/Gems/Blast/Code/Source/Editor/EditorBlastMeshDataComponent.cpp
index 23ec5ae524..9d0e4fe2ff 100644
--- a/Gems/Blast/Code/Source/Editor/EditorBlastMeshDataComponent.cpp
+++ b/Gems/Blast/Code/Source/Editor/EditorBlastMeshDataComponent.cpp
@@ -86,7 +86,7 @@ namespace Blast
 
     void EditorBlastMeshDataComponent::Activate()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::System);
+        AZ_PROFILE_FUNCTION(System);
         OnMeshAssetsChanged();
 
         m_meshFeatureProcessor =
@@ -100,7 +100,7 @@ namespace Blast
 
     void EditorBlastMeshDataComponent::Deactivate()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::System);
+        AZ_PROFILE_FUNCTION(System);
         EditorComponentBase::Deactivate();
         AZ::Render::MaterialComponentNotificationBus::Handler::BusDisconnect(GetEntityId());
         AZ::TransformNotificationBus::Handler::BusDisconnect(GetEntityId());
diff --git a/Gems/Blast/Code/Source/Family/ActorRenderManager.cpp b/Gems/Blast/Code/Source/Family/ActorRenderManager.cpp
index 98ea7d6741..aca1e94d16 100644
--- a/Gems/Blast/Code/Source/Family/ActorRenderManager.cpp
+++ b/Gems/Blast/Code/Source/Family/ActorRenderManager.cpp
@@ -33,7 +33,7 @@ namespace Blast
 
     void ActorRenderManager::OnActorCreated(const BlastActor& actor)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         const AZStd::vector<uint32_t>& chunkIndices = actor.GetChunkIndices();
 
@@ -47,7 +47,7 @@ namespace Blast
 
     void ActorRenderManager::OnActorDestroyed(const BlastActor& actor)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         const AZStd::vector<uint32_t>& chunkIndices = actor.GetChunkIndices();
 
@@ -62,7 +62,7 @@ namespace Blast
     {
         // It is more natural to have chunk entities be transform children of rigid body entity,
         // however having them separate and manually synchronizing transform is more efficient.
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         for (auto chunkId = 0u; chunkId < m_chunkCount; ++chunkId)
         {
diff --git a/Gems/Blast/Code/Source/Family/ActorTracker.cpp b/Gems/Blast/Code/Source/Family/ActorTracker.cpp
index 4c81c2d934..e441e7a074 100644
--- a/Gems/Blast/Code/Source/Family/ActorTracker.cpp
+++ b/Gems/Blast/Code/Source/Family/ActorTracker.cpp
@@ -6,6 +6,7 @@
  *
  */
 
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/Math/Transform.h>
 #include <Family/ActorTracker.h>
 #include <algorithm>
@@ -46,7 +47,7 @@ namespace Blast
 
     BlastActor* ActorTracker::FindClosestActor(const AZ::Vector3& position)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         const auto candidate = std::min_element(
             m_actors.begin(), m_actors.end(),
diff --git a/Gems/Blast/Code/Source/Family/BlastFamilyImpl.cpp b/Gems/Blast/Code/Source/Family/BlastFamilyImpl.cpp
index 2690a12f24..56c785b310 100644
--- a/Gems/Blast/Code/Source/Family/BlastFamilyImpl.cpp
+++ b/Gems/Blast/Code/Source/Family/BlastFamilyImpl.cpp
@@ -122,7 +122,7 @@ namespace Blast
 
     void BlastFamilyImpl::HandleEvents(const Nv::Blast::TkEvent* events, uint32_t eventCount)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         AZStd::vector<BlastActorDesc> newActors;
         AZStd::unordered_set<BlastActor*> actorsToDelete;
@@ -150,7 +150,7 @@ namespace Blast
         const Nv::Blast::TkSplitEvent* splitEvent, AZStd::vector<BlastActorDesc>& newActors,
         AZStd::unordered_set<BlastActor*>& actorsToDelete)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         AZ_Assert(splitEvent, "Received null TkSplitEvent from the Blast library.");
         if (!splitEvent)
@@ -256,7 +256,7 @@ namespace Blast
 
     void BlastFamilyImpl::CreateActors(const AZStd::vector<BlastActorDesc>& actorDescs)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         for (auto& actorDesc : actorDescs)
         {
@@ -268,7 +268,7 @@ namespace Blast
 
     void BlastFamilyImpl::DestroyActors(const AZStd::unordered_set<BlastActor*>& actors)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         for (const auto actor : actors)
         {
@@ -294,14 +294,14 @@ namespace Blast
 
     void BlastFamilyImpl::DispatchActorCreated(const BlastActor& actor)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         m_listener->OnActorCreated(*this, actor);
     }
 
     void BlastFamilyImpl::DispatchActorDestroyed(const BlastActor& actor)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         m_listener->OnActorDestroyed(*this, actor);
     }
diff --git a/Gems/EMotionFX/Code/EMotionFX/Source/EMotionFXManager.cpp b/Gems/EMotionFX/Code/EMotionFX/Source/EMotionFXManager.cpp
index 82b06c8171..300543c896 100644
--- a/Gems/EMotionFX/Code/EMotionFX/Source/EMotionFXManager.cpp
+++ b/Gems/EMotionFX/Code/EMotionFX/Source/EMotionFXManager.cpp
@@ -190,7 +190,7 @@ namespace EMotionFX
     // update
     void EMotionFXManager::Update(float timePassedInSeconds)
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Animation, "EMotionFXManager::Update");
+        AZ_PROFILE_SCOPE(Animation, "EMotionFXManager::Update");
 
         m_debugDraw->Clear();
         m_recorder->UpdatePlayMode(timePassedInSeconds);
diff --git a/Gems/EMotionFX/Code/EMotionFX/Source/MultiThreadScheduler.cpp b/Gems/EMotionFX/Code/EMotionFX/Source/MultiThreadScheduler.cpp
index 6f07936fe7..8b7fbad316 100644
--- a/Gems/EMotionFX/Code/EMotionFX/Source/MultiThreadScheduler.cpp
+++ b/Gems/EMotionFX/Code/EMotionFX/Source/MultiThreadScheduler.cpp
@@ -165,7 +165,7 @@ namespace EMotionFX
                 AZ::JobContext* jobContext = nullptr;
                 AZ::Job* job = AZ::CreateJobFunction([this, timePassedInSeconds, actorInstance]()
                 {
-                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Animation, "MultiThreadScheduler::Execute::ActorInstanceUpdateJob");
+                    AZ_PROFILE_SCOPE(Animation, "MultiThreadScheduler::Execute::ActorInstanceUpdateJob");
 
                     const AZ::u32 threadIndex = AZ::JobContext::GetGlobalContext()->GetJobManager().GetWorkerThreadId();                    
                     actorInstance->SetThreadIndex(threadIndex);
diff --git a/Gems/EMotionFX/Code/Source/Integration/Components/ActorComponent.cpp b/Gems/EMotionFX/Code/Source/Integration/Components/ActorComponent.cpp
index 303a7e118b..da4c72b70a 100644
--- a/Gems/EMotionFX/Code/Source/Integration/Components/ActorComponent.cpp
+++ b/Gems/EMotionFX/Code/Source/Integration/Components/ActorComponent.cpp
@@ -542,7 +542,7 @@ namespace EMotionFX
         //////////////////////////////////////////////////////////////////////////
         void ActorComponent::OnTick(float deltaTime, [[maybe_unused]] AZ::ScriptTimePoint time)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Animation);
+            AZ_PROFILE_FUNCTION(Animation);
 
             if (!m_actorInstance || !m_actorInstance->GetIsEnabled())
             {
diff --git a/Gems/ExpressionEvaluation/Code/Source/ExpressionEvaluationSystemComponent.cpp b/Gems/ExpressionEvaluation/Code/Source/ExpressionEvaluationSystemComponent.cpp
index 42ac124e6e..09b7bf878b 100644
--- a/Gems/ExpressionEvaluation/Code/Source/ExpressionEvaluationSystemComponent.cpp
+++ b/Gems/ExpressionEvaluation/Code/Source/ExpressionEvaluationSystemComponent.cpp
@@ -8,6 +8,7 @@
 
 #include <ExpressionEvaluationSystemComponent.h>
 
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/Serialization/SerializeContext.h>
 #include <AzCore/Serialization/EditContext.h>
 #include <AzCore/Serialization/EditContextConstants.inl>
@@ -251,7 +252,7 @@ namespace ExpressionEvaluation
 
     AZ::Outcome<void, ParsingError> ExpressionEvaluationSystemComponent::ParseRestrictedExpressionInPlace(const AZStd::unordered_set<ExpressionParserId>& parsers, AZStd::string_view expressionString, ExpressionTree& expressionTree) const
     {
-        AZ_PROFILE_TIMER("ExpressionEvaluation", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ExpressionEvaluation);
 
         expressionTree.ClearTree();
 
@@ -513,7 +514,7 @@ namespace ExpressionEvaluation
 
     ExpressionResult ExpressionEvaluationSystemComponent::Evaluate(const ExpressionTree& expressionTree) const
     {
-        AZ_PROFILE_TIMER("ExpressionEvaluation", __FUNCTION__);
+        AZ_PROFILE_SCOPE("ExpressionEvaluation", __FUNCTION__);
 
         ExpressionResultStack resultStack;
 
diff --git a/Gems/GradientSignal/Code/Include/GradientSignal/GradientSampler.h b/Gems/GradientSignal/Code/Include/GradientSignal/GradientSampler.h
index a7b0338ac1..c06265fb24 100644
--- a/Gems/GradientSignal/Code/Include/GradientSignal/GradientSampler.h
+++ b/Gems/GradientSignal/Code/Include/GradientSignal/GradientSampler.h
@@ -10,6 +10,7 @@
 
 #include <AzCore/Math/Vector3.h>
 #include <AzCore/Component/EntityId.h>
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/Outcome/Outcome.h>
 #include <AzCore/Memory/Memory.h>
 #include <AzCore/RTTI/ReflectContext.h>
@@ -87,7 +88,7 @@ namespace GradientSignal
 
     inline float GradientSampler::GetValue(const GradientSampleParams& sampleParams) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         if (m_opacity <= 0.0f || !m_gradientId.IsValid())
         {
diff --git a/Gems/GradientSignal/Code/Source/Components/DitherGradientComponent.cpp b/Gems/GradientSignal/Code/Source/Components/DitherGradientComponent.cpp
index 3b71278f86..dbc2cd2827 100644
--- a/Gems/GradientSignal/Code/Source/Components/DitherGradientComponent.cpp
+++ b/Gems/GradientSignal/Code/Source/Components/DitherGradientComponent.cpp
@@ -224,7 +224,7 @@ namespace GradientSignal
 
     float DitherGradientComponent::GetValue(const GradientSampleParams& sampleParams) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         const AZ::Vector3& coordinate = sampleParams.m_position;
 
diff --git a/Gems/GradientSignal/Code/Source/Components/GradientSurfaceDataComponent.cpp b/Gems/GradientSignal/Code/Source/Components/GradientSurfaceDataComponent.cpp
index d07f3a2e66..bdda0e48d2 100644
--- a/Gems/GradientSignal/Code/Source/Components/GradientSurfaceDataComponent.cpp
+++ b/Gems/GradientSignal/Code/Source/Components/GradientSurfaceDataComponent.cpp
@@ -263,7 +263,7 @@ namespace GradientSignal
 
     void GradientSurfaceDataComponent::OnCompositionChanged()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
         UpdateRegistryAndCache(m_modifierHandle);
     }
 
diff --git a/Gems/GradientSignal/Code/Source/Components/GradientTransformComponent.cpp b/Gems/GradientSignal/Code/Source/Components/GradientTransformComponent.cpp
index af92a0e16c..38936dc302 100644
--- a/Gems/GradientSignal/Code/Source/Components/GradientTransformComponent.cpp
+++ b/Gems/GradientSignal/Code/Source/Components/GradientTransformComponent.cpp
@@ -324,7 +324,7 @@ namespace GradientSignal
 
     void GradientTransformComponent::TransformPositionToUVW(const AZ::Vector3& inPosition, AZ::Vector3& outUVW, const bool shouldNormalizeOutput, bool& wasPointRejected) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::lock_guard<decltype(m_cacheMutex)> lock(m_cacheMutex);
 
@@ -415,7 +415,7 @@ namespace GradientSignal
 
     void GradientTransformComponent::UpdateFromShape()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::lock_guard<decltype(m_cacheMutex)> lock(m_cacheMutex);
 
diff --git a/Gems/GradientSignal/Code/Source/Components/ImageGradientComponent.cpp b/Gems/GradientSignal/Code/Source/Components/ImageGradientComponent.cpp
index 650dba209a..9e01b690e0 100644
--- a/Gems/GradientSignal/Code/Source/Components/ImageGradientComponent.cpp
+++ b/Gems/GradientSignal/Code/Source/Components/ImageGradientComponent.cpp
@@ -190,7 +190,7 @@ namespace GradientSignal
 
     float ImageGradientComponent::GetValue(const GradientSampleParams& sampleParams) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZ::Vector3 uvw = sampleParams.m_position;
 
diff --git a/Gems/GradientSignal/Code/Source/Components/LevelsGradientComponent.cpp b/Gems/GradientSignal/Code/Source/Components/LevelsGradientComponent.cpp
index 97dd8faa3c..af26ba494d 100644
--- a/Gems/GradientSignal/Code/Source/Components/LevelsGradientComponent.cpp
+++ b/Gems/GradientSignal/Code/Source/Components/LevelsGradientComponent.cpp
@@ -172,7 +172,7 @@ namespace GradientSignal
 
     float LevelsGradientComponent::GetValue(const GradientSampleParams& sampleParams) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         float output = 0.0f;
 
diff --git a/Gems/GradientSignal/Code/Source/Components/MixedGradientComponent.cpp b/Gems/GradientSignal/Code/Source/Components/MixedGradientComponent.cpp
index ddf349645b..5f6a18c7fb 100644
--- a/Gems/GradientSignal/Code/Source/Components/MixedGradientComponent.cpp
+++ b/Gems/GradientSignal/Code/Source/Components/MixedGradientComponent.cpp
@@ -257,7 +257,7 @@ namespace GradientSignal
 
     float MixedGradientComponent::GetValue(const GradientSampleParams& sampleParams) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         //accumulate the mixed/combined result of all layers and operations
         float result = 0.0f;
diff --git a/Gems/GradientSignal/Code/Source/Components/PerlinGradientComponent.cpp b/Gems/GradientSignal/Code/Source/Components/PerlinGradientComponent.cpp
index 6bc7108c64..e150ff4305 100644
--- a/Gems/GradientSignal/Code/Source/Components/PerlinGradientComponent.cpp
+++ b/Gems/GradientSignal/Code/Source/Components/PerlinGradientComponent.cpp
@@ -172,7 +172,7 @@ namespace GradientSignal
 
     float PerlinGradientComponent::GetValue(const GradientSampleParams& sampleParams) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         if (m_perlinImprovedNoise)
         {
diff --git a/Gems/GradientSignal/Code/Source/Components/RandomGradientComponent.cpp b/Gems/GradientSignal/Code/Source/Components/RandomGradientComponent.cpp
index 4e02e92db3..d28fe13aff 100644
--- a/Gems/GradientSignal/Code/Source/Components/RandomGradientComponent.cpp
+++ b/Gems/GradientSignal/Code/Source/Components/RandomGradientComponent.cpp
@@ -137,7 +137,7 @@ namespace GradientSignal
 
     float RandomGradientComponent::GetValue(const GradientSampleParams& sampleParams) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZ::Vector3 uvw = sampleParams.m_position;
 
diff --git a/Gems/GradientSignal/Code/Source/Components/ReferenceGradientComponent.cpp b/Gems/GradientSignal/Code/Source/Components/ReferenceGradientComponent.cpp
index 3c1fea6563..28ffaad7d3 100644
--- a/Gems/GradientSignal/Code/Source/Components/ReferenceGradientComponent.cpp
+++ b/Gems/GradientSignal/Code/Source/Components/ReferenceGradientComponent.cpp
@@ -131,7 +131,7 @@ namespace GradientSignal
 
     float ReferenceGradientComponent::GetValue(const GradientSampleParams& sampleParams) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         float output = 0.0f;
 
diff --git a/Gems/GradientSignal/Code/Source/Components/ShapeAreaFalloffGradientComponent.cpp b/Gems/GradientSignal/Code/Source/Components/ShapeAreaFalloffGradientComponent.cpp
index 3a3b9a2efd..cdf542bf51 100644
--- a/Gems/GradientSignal/Code/Source/Components/ShapeAreaFalloffGradientComponent.cpp
+++ b/Gems/GradientSignal/Code/Source/Components/ShapeAreaFalloffGradientComponent.cpp
@@ -157,7 +157,7 @@ namespace GradientSignal
 
     float ShapeAreaFalloffGradientComponent::GetValue(const GradientSampleParams& sampleParams) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         float distance = 0.0f;
         LmbrCentral::ShapeComponentRequestsBus::EventResult(distance, m_configuration.m_shapeEntityId, &LmbrCentral::ShapeComponentRequestsBus::Events::DistanceFromPoint, sampleParams.m_position);
diff --git a/Gems/GradientSignal/Code/Source/Components/SurfaceAltitudeGradientComponent.cpp b/Gems/GradientSignal/Code/Source/Components/SurfaceAltitudeGradientComponent.cpp
index c321fe2a54..476e0971f4 100644
--- a/Gems/GradientSignal/Code/Source/Components/SurfaceAltitudeGradientComponent.cpp
+++ b/Gems/GradientSignal/Code/Source/Components/SurfaceAltitudeGradientComponent.cpp
@@ -244,7 +244,7 @@ namespace GradientSignal
 
     void SurfaceAltitudeGradientComponent::UpdateFromShape()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::lock_guard<decltype(m_cacheMutex)> lock(m_cacheMutex);
 
diff --git a/Gems/GradientSignal/Code/Source/Components/SurfaceMaskGradientComponent.cpp b/Gems/GradientSignal/Code/Source/Components/SurfaceMaskGradientComponent.cpp
index 389fcf3678..7f46ad6e98 100644
--- a/Gems/GradientSignal/Code/Source/Components/SurfaceMaskGradientComponent.cpp
+++ b/Gems/GradientSignal/Code/Source/Components/SurfaceMaskGradientComponent.cpp
@@ -161,7 +161,7 @@ namespace GradientSignal
 
     float SurfaceMaskGradientComponent::GetValue(const GradientSampleParams& params) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         float result = 0.0f;
 
diff --git a/Gems/GradientSignal/Code/Source/ImageAsset.cpp b/Gems/GradientSignal/Code/Source/ImageAsset.cpp
index 5d3397bbbd..c67f86c6b8 100644
--- a/Gems/GradientSignal/Code/Source/ImageAsset.cpp
+++ b/Gems/GradientSignal/Code/Source/ImageAsset.cpp
@@ -153,7 +153,7 @@ namespace GradientSignal
 
     float GetValueFromImageAsset(const AZ::Data::Asset<ImageAsset>& imageAsset, const AZ::Vector3& uvw, float tilingX, float tilingY, float defaultValue)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         if (imageAsset.IsReady())
         {
diff --git a/Gems/GraphCanvas/Code/StaticLib/GraphCanvas/Editor/GraphCanvasProfiler.h b/Gems/GraphCanvas/Code/StaticLib/GraphCanvas/Editor/GraphCanvasProfiler.h
index 60c147e98e..ae55baa681 100644
--- a/Gems/GraphCanvas/Code/StaticLib/GraphCanvas/Editor/GraphCanvasProfiler.h
+++ b/Gems/GraphCanvas/Code/StaticLib/GraphCanvas/Editor/GraphCanvasProfiler.h
@@ -9,12 +9,12 @@
 
 #include <AzCore/Debug/Profiler.h>
  
-#define GRAPH_CANVAS_PROFILE_FUNCTION() AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
-#define GRAPH_CANVAS_PROFILE_SCOPE(message) AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, message);
+#define GRAPH_CANVAS_PROFILE_FUNCTION() AZ_PROFILE_FUNCTION(AzToolsFramework);
+#define GRAPH_CANVAS_PROFILE_SCOPE(message) AZ_PROFILE_SCOPE(AzToolsFramework, message);
 
 #if GRAPH_CANVAS_ENABLE_DETAILED_PROFILING
-#define GRAPH_CANVAS_DETAILED_PROFILE_FUNCTION() AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
-#define GRAPH_CANVAS_DETAILED_PROFILE_SCOPE(message) AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, message);
+#define GRAPH_CANVAS_DETAILED_PROFILE_FUNCTION() AZ_PROFILE_FUNCTION(AzToolsFramework);
+#define GRAPH_CANVAS_DETAILED_PROFILE_SCOPE(message) AZ_PROFILE_SCOPE(AzToolsFramework, message);
 #else
 #define GRAPH_CANVAS_DETAILED_PROFILE_FUNCTION()
 #define GRAPH_CANVAS_DETAILED_PROFILE_SCOPE(message)
diff --git a/Gems/LmbrCentral/Code/include/LmbrCentral/Dependency/DependencyMonitor.h b/Gems/LmbrCentral/Code/include/LmbrCentral/Dependency/DependencyMonitor.h
index 4e6e85250a..230655a455 100644
--- a/Gems/LmbrCentral/Code/include/LmbrCentral/Dependency/DependencyMonitor.h
+++ b/Gems/LmbrCentral/Code/include/LmbrCentral/Dependency/DependencyMonitor.h
@@ -10,6 +10,7 @@
 
 #include <AzCore/Component/EntityBus.h>
 #include <AzCore/Component/TransformBus.h>
+#include <AzCore/Debug/Profiler.h>
 #include <LmbrCentral/Shape/ShapeComponentBus.h>
 #include <LmbrCentral/Dependency/DependencyNotificationBus.h>
 #include <AzCore/Asset/AssetCommon.h>
diff --git a/Gems/LmbrCentral/Code/include/LmbrCentral/Dependency/DependencyMonitor.inl b/Gems/LmbrCentral/Code/include/LmbrCentral/Dependency/DependencyMonitor.inl
index d6ad18325a..cc4a3e2740 100644
--- a/Gems/LmbrCentral/Code/include/LmbrCentral/Dependency/DependencyMonitor.inl
+++ b/Gems/LmbrCentral/Code/include/LmbrCentral/Dependency/DependencyMonitor.inl
@@ -15,7 +15,7 @@ namespace LmbrCentral
 
     inline void DependencyMonitor::Reset()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZ::Data::AssetBus::MultiHandler::BusDisconnect();
         AZ::EntityBus::MultiHandler::BusDisconnect();
@@ -35,7 +35,7 @@ namespace LmbrCentral
 
     inline void DependencyMonitor::ConnectDependency(const AZ::EntityId& entityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
         if (entityId.IsValid())
         {
             AZ::EntityBus::MultiHandler::BusConnect(entityId);
@@ -47,7 +47,7 @@ namespace LmbrCentral
 
     inline void DependencyMonitor::ConnectDependencies(const AZStd::vector<AZ::EntityId>& entityIds)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         for (const auto& entityId : entityIds)
         {
@@ -57,7 +57,7 @@ namespace LmbrCentral
 
     inline void DependencyMonitor::ConnectDependency(const AZ::Data::AssetId& assetId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         if (assetId.IsValid())
         {
@@ -120,7 +120,7 @@ namespace LmbrCentral
 
     inline void DependencyMonitor::SendNotification()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         //test if notification is in progress to prevent recursion in case of nested dependencies
         if (!m_notificationInProgress)
diff --git a/Gems/LyShine/Code/Editor/PropertiesContainer.cpp b/Gems/LyShine/Code/Editor/PropertiesContainer.cpp
index 21b3b99b02..9f9023f84d 100644
--- a/Gems/LyShine/Code/Editor/PropertiesContainer.cpp
+++ b/Gems/LyShine/Code/Editor/PropertiesContainer.cpp
@@ -595,7 +595,7 @@ bool PropertiesContainer::DoesIntersectNonSelectedComponentEditor(const QRect& g
 
 void PropertiesContainer::ClearComponentEditorSelection()
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+    AZ_PROFILE_FUNCTION(AzToolsFramework);
     for (auto componentEditor : m_componentEditors)
     {
         componentEditor->SetSelected(false);
diff --git a/Gems/LyShine/Code/Editor/UiSliceManager.cpp b/Gems/LyShine/Code/Editor/UiSliceManager.cpp
index c86da38d80..97e9a51e11 100644
--- a/Gems/LyShine/Code/Editor/UiSliceManager.cpp
+++ b/Gems/LyShine/Code/Editor/UiSliceManager.cpp
@@ -158,7 +158,7 @@ bool UiSliceManager::MakeNewSlice(
     bool inheritSlices,
     AZ::SerializeContext* serializeContext)
 {
-    AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+    AZ_PROFILE_FUNCTION(AzToolsFramework);
 
     if (entities.empty())
     {
@@ -240,7 +240,7 @@ bool UiSliceManager::MakeNewSlice(
     // Setup and execute transaction for the new slice.
     //
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "UiSliceManager::MakeNewSlice:SetupAndExecuteTransaction");
+        AZ_PROFILE_SCOPE(AzToolsFramework, "UiSliceManager::MakeNewSlice:SetupAndExecuteTransaction");
 
         using AzToolsFramework::SliceUtilities::SliceTransaction;
 
@@ -249,7 +249,7 @@ bool UiSliceManager::MakeNewSlice(
             [this, &entitiesToInclude, &commonParent, &insertBefore]
         (SliceTransaction::TransactionPtr transaction, const char* fullPath, const SliceTransaction::SliceAssetPtr& /*asset*/) -> void
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "UiSliceManager::MakeNewSlice:PostSaveCallback");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "UiSliceManager::MakeNewSlice:PostSaveCallback");
             // Once the asset is processed and ready, we can replace the source entities with an instance of the new slice.
             UiEditorEntityContextRequestBus::Event(m_entityContextId,
                 &UiEditorEntityContextRequestBus::Events::QueueSliceReplacement,
@@ -260,7 +260,7 @@ bool UiSliceManager::MakeNewSlice(
 
         // Add entities
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "UiSliceManager::MakeNewSlice:SetupAndExecuteTransaction:AddEntities");
+            AZ_PROFILE_SCOPE(AzToolsFramework, "UiSliceManager::MakeNewSlice:SetupAndExecuteTransaction:AddEntities");
             for (const AZ::EntityId& entityId : orderedEntityList)
             {
                 SliceTransaction::Result addResult = transaction->AddEntity(entityId, !inheritSlices ? SliceTransaction::SliceAddEntityFlags::DiscardSliceAncestry : 0);
@@ -348,7 +348,7 @@ AzToolsFramework::SliceUtilities::SliceTransaction::Result SlicePreSaveCallbackF
     [[maybe_unused]] const char* fullPath,
     AzToolsFramework::SliceUtilities::SliceTransaction::SliceAssetPtr& asset)
 {
-    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzToolsFramework, "SlicePreSaveCallbackForUiEntities");
+    AZ_PROFILE_SCOPE(AzToolsFramework, "SlicePreSaveCallbackForUiEntities");
 
     // we want to ensure that "bad" data never gets pushed to a slice
     // This mostly relates to the m_childEntityIdOrder array since this is something that
diff --git a/Gems/MultiplayerCompression/Code/Tests/MultiplayerCompressionTest.cpp b/Gems/MultiplayerCompression/Code/Tests/MultiplayerCompressionTest.cpp
index 91839b1e23..5a3304fecd 100644
--- a/Gems/MultiplayerCompression/Code/Tests/MultiplayerCompressionTest.cpp
+++ b/Gems/MultiplayerCompression/Code/Tests/MultiplayerCompressionTest.cpp
@@ -12,6 +12,7 @@
 #include <LZ4Compressor.h>
 
 #include <AzCore/Compression/Compression.h>
+#include <AzCore/std/time.h>
 #include <AzNetworking/DataStructures/ByteBuffer.h>
 #include <AzNetworking/Serialization/NetworkInputSerializer.h>
 #include <AzTest/AzTest.h>
diff --git a/Gems/NvCloth/Code/Source/Components/ClothComponentMesh/ActorClothSkinning.cpp b/Gems/NvCloth/Code/Source/Components/ClothComponentMesh/ActorClothSkinning.cpp
index 8baea091a2..ef42aba7f0 100644
--- a/Gems/NvCloth/Code/Source/Components/ClothComponentMesh/ActorClothSkinning.cpp
+++ b/Gems/NvCloth/Code/Source/Components/ClothComponentMesh/ActorClothSkinning.cpp
@@ -233,7 +233,7 @@ namespace NvCloth
 
     void ActorClothSkinningLinear::UpdateSkinning()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+        AZ_PROFILE_FUNCTION(Cloth);
 
         m_skinningMatrices = Internal::ObtainSkinningMatrices(m_entityId);
     }
@@ -250,7 +250,7 @@ namespace NvCloth
             return;
         }
 
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+        AZ_PROFILE_FUNCTION(Cloth);
 
         const size_t vertexCount = m_simulatedVertices.size();
         for (size_t index = 0; index < vertexCount; ++index)
@@ -274,7 +274,7 @@ namespace NvCloth
             return;
         }
 
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+        AZ_PROFILE_FUNCTION(Cloth);
 
         for (const AZ::u32 index : m_nonSimulatedVertices)
         {
@@ -342,7 +342,7 @@ namespace NvCloth
 
     void ActorClothSkinningDualQuaternion::UpdateSkinning()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+        AZ_PROFILE_FUNCTION(Cloth);
 
         m_skinningDualQuaternions = Internal::ObtainSkinningDualQuaternions(m_entityId, m_jointIndices);
     }
@@ -359,7 +359,7 @@ namespace NvCloth
             return;
         }
 
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+        AZ_PROFILE_FUNCTION(Cloth);
 
         const size_t vertexCount = m_simulatedVertices.size();
         for (size_t index = 0; index < vertexCount; ++index)
@@ -383,7 +383,7 @@ namespace NvCloth
             return;
         }
 
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+        AZ_PROFILE_FUNCTION(Cloth);
 
         for (const AZ::u32 index : m_nonSimulatedVertices)
         {
diff --git a/Gems/NvCloth/Code/Source/Components/ClothComponentMesh/ClothComponentMesh.cpp b/Gems/NvCloth/Code/Source/Components/ClothComponentMesh/ClothComponentMesh.cpp
index 5a7564d72a..54e9619eea 100644
--- a/Gems/NvCloth/Code/Source/Components/ClothComponentMesh/ClothComponentMesh.cpp
+++ b/Gems/NvCloth/Code/Source/Components/ClothComponentMesh/ClothComponentMesh.cpp
@@ -250,7 +250,7 @@ namespace NvCloth
         [[maybe_unused]] ClothId clothId,
         float deltaTime)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+        AZ_PROFILE_FUNCTION(Cloth);
 
         UpdateSimulationCollisions();
 
@@ -267,7 +267,7 @@ namespace NvCloth
         [[maybe_unused]] float deltaTime,
         const AZStd::vector<SimParticleFormat>& updatedParticles)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+        AZ_PROFILE_FUNCTION(Cloth);
 
         // Next buffer index of the render data
         m_renderDataBufferIndex = (m_renderDataBufferIndex + 1) % RenderDataBufferSize;
@@ -326,7 +326,7 @@ namespace NvCloth
     {
         if (m_actorClothColliders)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+            AZ_PROFILE_FUNCTION(Cloth);
 
             m_actorClothColliders->Update();
 
@@ -342,7 +342,7 @@ namespace NvCloth
     {
         if (m_actorClothSkinning)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+            AZ_PROFILE_FUNCTION(Cloth);
 
             m_actorClothSkinning->UpdateSkinning();
 
@@ -376,7 +376,7 @@ namespace NvCloth
 
     void ClothComponentMesh::UpdateSimulationConstraints()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+        AZ_PROFILE_FUNCTION(Cloth);
 
         m_motionConstraints = m_clothConstraints->GetMotionConstraints();
         m_separationConstraints = m_clothConstraints->GetSeparationConstraints();
@@ -396,7 +396,7 @@ namespace NvCloth
 
     void ClothComponentMesh::UpdateRenderData(const AZStd::vector<SimParticleFormat>& particles)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+        AZ_PROFILE_FUNCTION(Cloth);
 
         if (!m_cloth)
         {
@@ -449,7 +449,7 @@ namespace NvCloth
 
     void ClothComponentMesh::CopyRenderDataToModel()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+        AZ_PROFILE_FUNCTION(Cloth);
 
         // Previous buffer index of the render data
         const AZ::u32 previousBufferIndex = (m_renderDataBufferIndex + RenderDataBufferSize - 1) % RenderDataBufferSize;
diff --git a/Gems/NvCloth/Code/Source/System/Cloth.cpp b/Gems/NvCloth/Code/Source/System/Cloth.cpp
index 2aad4c402f..c71d1bd584 100644
--- a/Gems/NvCloth/Code/Source/System/Cloth.cpp
+++ b/Gems/NvCloth/Code/Source/System/Cloth.cpp
@@ -165,7 +165,7 @@ namespace NvCloth
 
     void Cloth::Update()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+        AZ_PROFILE_FUNCTION(Cloth);
 
         ResolveStaticParticles();
 
diff --git a/Gems/NvCloth/Code/Source/System/FabricCooker.cpp b/Gems/NvCloth/Code/Source/System/FabricCooker.cpp
index 668675aeaa..e9da64f970 100644
--- a/Gems/NvCloth/Code/Source/System/FabricCooker.cpp
+++ b/Gems/NvCloth/Code/Source/System/FabricCooker.cpp
@@ -6,6 +6,7 @@
  *
  */
 
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/std/smart_ptr/unique_ptr.h>
 #include <AzCore/std/containers/map.h>
 #include <AzCore/std/containers/set.h>
@@ -304,7 +305,7 @@ namespace NvCloth
         const AZ::Vector3& fabricGravity,
         bool useGeodesicTether)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+        AZ_PROFILE_FUNCTION(Cloth);
 
         return Internal::Cook(particles, indices, fabricGravity, useGeodesicTether);
     }
@@ -317,7 +318,7 @@ namespace NvCloth
         AZStd::vector<int>& remappedVertices,
         bool removeStaticTriangles)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+        AZ_PROFILE_FUNCTION(Cloth);
 
         // Weld vertices together
         AZStd::vector<SimParticleFormat> weldedParticles;
diff --git a/Gems/NvCloth/Code/Source/System/Solver.cpp b/Gems/NvCloth/Code/Source/System/Solver.cpp
index 6c20631409..3db9d3a1d9 100644
--- a/Gems/NvCloth/Code/Source/System/Solver.cpp
+++ b/Gems/NvCloth/Code/Source/System/Solver.cpp
@@ -110,7 +110,7 @@ namespace NvCloth
 
         AZ_Assert(!m_isSimulating, "Please make sure the ongoing simulation is finished before attempting to start a new one");
 
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+        AZ_PROFILE_FUNCTION(Cloth);
 
         m_deltaTime = deltaTime;
         m_simulationCompletion.Reset(true /*isClearDependent*/);
@@ -147,7 +147,7 @@ namespace NvCloth
             return;
         }
 
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+        AZ_PROFILE_FUNCTION(Cloth);
 
         // Waiting for the simulation pass completition.
         m_simulationCompletion.StartAndWaitForCompletion();
@@ -191,14 +191,14 @@ namespace NvCloth
 
     void Solver::ClothsSimulationJob::Process()
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Cloth, "NvCloth::BeginSimulationJob");
+        AZ_PROFILE_SCOPE(Cloth, "NvCloth::BeginSimulationJob");
 
         if (m_solver->beginSimulation(m_deltaTime))
         {
             // Setup the end simulation job.
             AZ::Job* endSimulationJob = AZ::CreateJobFunction([solver = m_solver]
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Cloth, "NvCloth::EndSimulationJob");
+                AZ_PROFILE_SCOPE(Cloth, "NvCloth::EndSimulationJob");
                 solver->endSimulation();
             }, true /*isAutoDelete*/);
 
@@ -209,7 +209,7 @@ namespace NvCloth
             {
                 AZ::Job* chunkSimulationJob = AZ::CreateJobFunction([solver = m_solver, chunkIndex]
                 {
-                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Cloth, "NvCloth::ChunkSimulationJob");
+                    AZ_PROFILE_SCOPE(Cloth, "NvCloth::ChunkSimulationJob");
                     solver->simulateChunk(chunkIndex);
                 }, true /*isAutoDelete*/);
 
@@ -241,7 +241,7 @@ namespace NvCloth
         {
             AZ::Job* eventSignalJob = AZ::CreateJobFunction([cloth, deltaTime = m_deltaTime]
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Cloth, "NvCloth::PostSimulationJob");
+                AZ_PROFILE_SCOPE(Cloth, "NvCloth::PostSimulationJob");
 
                 // Update the cloth data after the simulation
                 cloth->Update();
@@ -270,7 +270,7 @@ namespace NvCloth
         {
             AZ::Job* eventSignalJob = AZ::CreateJobFunction([cloth, deltaTime = m_deltaTime]
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Cloth, "NvCloth::PreSimulationJob");
+                AZ_PROFILE_SCOPE(Cloth, "NvCloth::PreSimulationJob");
 
                 // Issue pre-simulation events
                 cloth->m_preSimulationEvent.Signal(cloth->GetId(), deltaTime);
diff --git a/Gems/NvCloth/Code/Source/System/SystemComponent.cpp b/Gems/NvCloth/Code/Source/System/SystemComponent.cpp
index 083a866a4e..02a57cea6f 100644
--- a/Gems/NvCloth/Code/Source/System/SystemComponent.cpp
+++ b/Gems/NvCloth/Code/Source/System/SystemComponent.cpp
@@ -106,11 +106,11 @@ namespace NvCloth
             {
                 if (detached)
                 {
-                    AZ_PROFILE_INTERVAL_START(AZ::Debug::ProfileCategory::Cloth, AZ::Crc32(eventName), eventName);
+                    AZ_PROFILE_INTERVAL_START(Cloth, AZ::Crc32(eventName), eventName);
                 }
                 else
                 {
-                    AZ_PROFILE_EVENT_BEGIN(AZ::Debug::ProfileCategory::Cloth, eventName);
+                    AZ_PROFILE_BEGIN(Cloth, eventName);
                 }
                 return nullptr;
             }
@@ -121,11 +121,11 @@ namespace NvCloth
             {
                 if (detached)
                 {
-                    AZ_PROFILE_INTERVAL_END(AZ::Debug::ProfileCategory::Cloth, AZ::Crc32(eventName));
+                    AZ_PROFILE_INTERVAL_END(Cloth, AZ::Crc32(eventName));
                 }
                 else
                 {
-                    AZ_PROFILE_EVENT_END(AZ::Debug::ProfileCategory::Cloth);
+                    AZ_PROFILE_END();
                 }
             }
         };
@@ -309,7 +309,7 @@ namespace NvCloth
         const AZStd::vector<SimParticleFormat>& initialParticles,
         const FabricCookedData& fabricCookedData)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+        AZ_PROFILE_FUNCTION(Cloth);
 
         FabricId fabricId = FindOrCreateFabric(fabricCookedData);
         if (!fabricId.IsValid())
@@ -403,7 +403,7 @@ namespace NvCloth
         float deltaTime,
         [[maybe_unused]] AZ::ScriptTimePoint time)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+        AZ_PROFILE_FUNCTION(Cloth);
 
         for (auto& solverIt : m_solvers)
         {
diff --git a/Gems/NvCloth/Code/Source/System/TangentSpaceHelper.cpp b/Gems/NvCloth/Code/Source/System/TangentSpaceHelper.cpp
index 3c47ad46fd..17d8c629e6 100644
--- a/Gems/NvCloth/Code/Source/System/TangentSpaceHelper.cpp
+++ b/Gems/NvCloth/Code/Source/System/TangentSpaceHelper.cpp
@@ -8,6 +8,8 @@
 
 #include <System/TangentSpaceHelper.h>
 
+#include <AzCore/Debug/Profiler.h>
+
 namespace NvCloth
 {
     namespace
@@ -20,7 +22,7 @@ namespace NvCloth
         const AZStd::vector<SimIndexType>& indices,
         AZStd::vector<AZ::Vector3>& outNormals)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+        AZ_PROFILE_FUNCTION(Cloth);
 
         if ((indices.size() % 3) != 0)
         {
@@ -86,7 +88,7 @@ namespace NvCloth
         AZStd::vector<AZ::Vector3>& outTangents,
         AZStd::vector<AZ::Vector3>& outBitangents)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+        AZ_PROFILE_FUNCTION(Cloth);
 
         if ((indices.size() % 3) != 0)
         {
@@ -174,7 +176,7 @@ namespace NvCloth
         AZStd::vector<AZ::Vector3>& outBitangents,
         AZStd::vector<AZ::Vector3>& outNormals)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+        AZ_PROFILE_FUNCTION(Cloth);
 
         if ((indices.size() % 3) != 0)
         {
diff --git a/Gems/NvCloth/Code/Source/Utils/MeshAssetHelper.cpp b/Gems/NvCloth/Code/Source/Utils/MeshAssetHelper.cpp
index da48485dfa..c95c8896ab 100644
--- a/Gems/NvCloth/Code/Source/Utils/MeshAssetHelper.cpp
+++ b/Gems/NvCloth/Code/Source/Utils/MeshAssetHelper.cpp
@@ -66,7 +66,7 @@ namespace NvCloth
         MeshNodeInfo& meshNodeInfo,
         MeshClothInfo& meshClothInfo)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Cloth);
+        AZ_PROFILE_FUNCTION(Cloth);
 
         AZ::Data::Asset<AZ::RPI::ModelAsset> modelDataAsset;
         AZ::Render::MeshComponentRequestBus::EventResult(
diff --git a/Gems/PhysX/Code/Source/ForceRegionComponent.cpp b/Gems/PhysX/Code/Source/ForceRegionComponent.cpp
index af929bbab3..f8f5f1991e 100644
--- a/Gems/PhysX/Code/Source/ForceRegionComponent.cpp
+++ b/Gems/PhysX/Code/Source/ForceRegionComponent.cpp
@@ -115,7 +115,7 @@ namespace PhysX
 
     void ForceRegionComponent::PostPhysicsSubTick(float fixedDeltaTime)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         for (auto entityId : m_entities)
         {
diff --git a/Gems/PhysX/Code/Source/Pipeline/HeightFieldAssetHandler.cpp b/Gems/PhysX/Code/Source/Pipeline/HeightFieldAssetHandler.cpp
index d21bd02737..e4d64d4139 100644
--- a/Gems/PhysX/Code/Source/Pipeline/HeightFieldAssetHandler.cpp
+++ b/Gems/PhysX/Code/Source/Pipeline/HeightFieldAssetHandler.cpp
@@ -106,7 +106,7 @@ namespace PhysX
             AZStd::shared_ptr<AZ::Data::AssetDataStream> stream,
             [[maybe_unused]] const AZ::Data::AssetFilterCB& assetLoadFilterCB)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+            AZ_PROFILE_FUNCTION(Physics);
 
             HeightFieldAsset* physXHeightFieldAsset = asset.GetAs<HeightFieldAsset>();
             if (!physXHeightFieldAsset)
@@ -166,7 +166,7 @@ namespace PhysX
 
         bool HeightFieldAssetHandler::SaveAssetData(const AZ::Data::Asset<AZ::Data::AssetData>& asset, AZ::IO::GenericStream* stream)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+            AZ_PROFILE_FUNCTION(Physics);
 
             HeightFieldAsset* physXHeightFieldAsset = asset.GetAs<HeightFieldAsset>();
             if (!physXHeightFieldAsset)
diff --git a/Gems/PhysX/Code/Source/Scene/PhysXScene.cpp b/Gems/PhysX/Code/Source/Scene/PhysXScene.cpp
index a47f0ba16f..bdd253d70c 100644
--- a/Gems/PhysX/Code/Source/Scene/PhysXScene.cpp
+++ b/Gems/PhysX/Code/Source/Scene/PhysXScene.cpp
@@ -529,7 +529,7 @@ namespace PhysX
 
     void PhysXScene::StartSimulation(float deltatime)
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Physics, "PhysXScene::StartSimulation");
+        AZ_PROFILE_SCOPE(Physics, "PhysXScene::StartSimulation");
 
         if (!IsEnabled())
         {
@@ -537,7 +537,7 @@ namespace PhysX
         }
 
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Physics, "OnSceneSimulationStartEvent::Signaled");
+            AZ_PROFILE_SCOPE(Physics, "OnSceneSimulationStartEvent::Signaled");
             m_sceneSimuationStartEvent.Signal(m_sceneHandle, deltatime);
         }
 
@@ -549,7 +549,7 @@ namespace PhysX
 
     void PhysXScene::FinishSimulation()
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Physics, "PhysXScene::FinishSimulation");
+        AZ_PROFILE_SCOPE(Physics, "PhysXScene::FinishSimulation");
 
         if (!IsEnabled())
         {
@@ -557,7 +557,7 @@ namespace PhysX
         }
 
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Physics, "PhysXScene::CheckResults");
+            AZ_PROFILE_SCOPE(Physics, "PhysXScene::CheckResults");
 
             // Wait for the simulation to complete.
             // In the multithreaded environment we need to make sure we don't lock the scene for write here.
@@ -569,7 +569,7 @@ namespace PhysX
 
         bool activeActorsEnabled = false;
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Physics, "PhysXScene::FetchResults");
+            AZ_PROFILE_SCOPE(Physics, "PhysXScene::FetchResults");
             PHYSX_SCENE_WRITE_LOCK(m_pxScene);
 
             activeActorsEnabled = m_pxScene->getFlags() & physx::PxSceneFlag::eENABLE_ACTIVE_ACTORS;
@@ -580,7 +580,7 @@ namespace PhysX
         
         if (activeActorsEnabled)
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Physics, "PhysXScene::ActiveActors");
+            AZ_PROFILE_SCOPE(Physics, "PhysXScene::ActiveActors");
 
             PHYSX_SCENE_READ_LOCK(m_pxScene);
 
@@ -602,7 +602,7 @@ namespace PhysX
         ClearDeferedDeletions();
 
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Physics, "OnSceneSimulationFinishedEvent::Signaled");
+            AZ_PROFILE_SCOPE(Physics, "OnSceneSimulationFinishedEvent::Signaled");
             m_sceneSimuationFinishEvent.Signal(m_sceneHandle, m_currentDeltaTime);
         }
 
@@ -1108,7 +1108,7 @@ namespace PhysX
 
     void PhysXScene::ProcessTriggerEvents()
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Physics, "PhysXScene::ProcessTriggerEvents");
+        AZ_PROFILE_SCOPE(Physics, "PhysXScene::ProcessTriggerEvents");
 
         AzPhysics::TriggerEventList& triggers = m_simulationEventCallback.GetQueuedTriggerEvents();
         if (triggers.empty())
@@ -1135,7 +1135,7 @@ namespace PhysX
 
     void PhysXScene::ProcessCollisionEvents()
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Physics, "PhysXScene::ProcessCollisionEvents");
+        AZ_PROFILE_SCOPE(Physics, "PhysXScene::ProcessCollisionEvents");
 
         AzPhysics::CollisionEventList& collisions = m_simulationEventCallback.GetQueuedCollisionEvents();
         if (collisions.empty())
@@ -1181,7 +1181,7 @@ namespace PhysX
             return;
         }
 
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Physics, "PhysX::Statistics");
+        AZ_PROFILE_SCOPE(Physics, "PhysX::Statistics");
 
         physx::PxSimulationStatistics stats;
 
@@ -1193,33 +1193,33 @@ namespace PhysX
         [[maybe_unused]] const char* RootCategory = "PhysX/%s/%s";
 
         [[maybe_unused]] const char* ShapesSubCategory = "Shapes";
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbShapes[PxGeometryType::eSPHERE], RootCategory, ShapesSubCategory, "Sphere");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbShapes[PxGeometryType::ePLANE], RootCategory, ShapesSubCategory, "Plane");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbShapes[PxGeometryType::eCAPSULE], RootCategory, ShapesSubCategory, "Capsule");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbShapes[PxGeometryType::eBOX], RootCategory, ShapesSubCategory, "Box");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbShapes[PxGeometryType::eCONVEXMESH], RootCategory, ShapesSubCategory, "ConvexMesh");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbShapes[PxGeometryType::eTRIANGLEMESH], RootCategory, ShapesSubCategory, "TriangleMesh");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbShapes[PxGeometryType::eHEIGHTFIELD], RootCategory, ShapesSubCategory, "Heightfield");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbShapes[PxGeometryType::eSPHERE], RootCategory, ShapesSubCategory, "Sphere");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbShapes[PxGeometryType::ePLANE], RootCategory, ShapesSubCategory, "Plane");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbShapes[PxGeometryType::eCAPSULE], RootCategory, ShapesSubCategory, "Capsule");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbShapes[PxGeometryType::eBOX], RootCategory, ShapesSubCategory, "Box");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbShapes[PxGeometryType::eCONVEXMESH], RootCategory, ShapesSubCategory, "ConvexMesh");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbShapes[PxGeometryType::eTRIANGLEMESH], RootCategory, ShapesSubCategory, "TriangleMesh");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbShapes[PxGeometryType::eHEIGHTFIELD], RootCategory, ShapesSubCategory, "Heightfield");
 
         [[maybe_unused]] const char* ObjectsSubCategory = "Objects";
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbActiveConstraints, RootCategory, ObjectsSubCategory, "ActiveConstraints");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbActiveDynamicBodies, RootCategory, ObjectsSubCategory, "ActiveDynamicBodies");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbActiveKinematicBodies, RootCategory, ObjectsSubCategory, "ActiveKinematicBodies");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbStaticBodies, RootCategory, ObjectsSubCategory, "StaticBodies");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbDynamicBodies, RootCategory, ObjectsSubCategory, "DynamicBodies");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbKinematicBodies, RootCategory, ObjectsSubCategory, "KinematicBodies");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbAggregates, RootCategory, ObjectsSubCategory, "Aggregates");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbArticulations, RootCategory, ObjectsSubCategory, "Articulations");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbActiveConstraints, RootCategory, ObjectsSubCategory, "ActiveConstraints");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbActiveDynamicBodies, RootCategory, ObjectsSubCategory, "ActiveDynamicBodies");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbActiveKinematicBodies, RootCategory, ObjectsSubCategory, "ActiveKinematicBodies");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbStaticBodies, RootCategory, ObjectsSubCategory, "StaticBodies");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbDynamicBodies, RootCategory, ObjectsSubCategory, "DynamicBodies");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbKinematicBodies, RootCategory, ObjectsSubCategory, "KinematicBodies");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbAggregates, RootCategory, ObjectsSubCategory, "Aggregates");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbArticulations, RootCategory, ObjectsSubCategory, "Articulations");
 
         [[maybe_unused]] const char* SolverSubCategory = "Solver";
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbAxisSolverConstraints, RootCategory, SolverSubCategory, "AxisSolverConstraints");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.compressedContactSize, RootCategory, SolverSubCategory, "CompressedContactSize");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.requiredContactConstraintMemory, RootCategory, SolverSubCategory, "RequiredContactConstraintMemory");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.peakConstraintMemory, RootCategory, SolverSubCategory, "PeakConstraintMemory");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbAxisSolverConstraints, RootCategory, SolverSubCategory, "AxisSolverConstraints");
+        AZ_PROFILE_DATAPOINT(Physics, stats.compressedContactSize, RootCategory, SolverSubCategory, "CompressedContactSize");
+        AZ_PROFILE_DATAPOINT(Physics, stats.requiredContactConstraintMemory, RootCategory, SolverSubCategory, "RequiredContactConstraintMemory");
+        AZ_PROFILE_DATAPOINT(Physics, stats.peakConstraintMemory, RootCategory, SolverSubCategory, "PeakConstraintMemory");
 
         [[maybe_unused]] const char* BroadphaseSubCategory = "Broadphase";
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.getNbBroadPhaseAdds(), RootCategory, BroadphaseSubCategory, "BroadPhaseAdds");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.getNbBroadPhaseRemoves(), RootCategory, BroadphaseSubCategory, "BroadPhaseRemoves");
+        AZ_PROFILE_DATAPOINT(Physics, stats.getNbBroadPhaseAdds(), RootCategory, BroadphaseSubCategory, "BroadPhaseAdds");
+        AZ_PROFILE_DATAPOINT(Physics, stats.getNbBroadPhaseRemoves(), RootCategory, BroadphaseSubCategory, "BroadPhaseRemoves");
 
         // Compute pair stats for all geometry types
         AZ::u32 ccdPairs = 0;
@@ -1240,16 +1240,16 @@ namespace PhysX
         }
 
         [[maybe_unused]] const char* CollisionsSubCategory = "Collisions";
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, ccdPairs, RootCategory, CollisionsSubCategory, "CCDPairs");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, modifiedPairs, RootCategory, CollisionsSubCategory, "ModifiedPairs");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, triggerPairs, RootCategory, CollisionsSubCategory, "TriggerPairs");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbDiscreteContactPairsTotal, RootCategory, CollisionsSubCategory, "DiscreteContactPairsTotal");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbDiscreteContactPairsWithCacheHits, RootCategory, CollisionsSubCategory, "DiscreteContactPairsWithCacheHits");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbDiscreteContactPairsWithContacts, RootCategory, CollisionsSubCategory, "DiscreteContactPairsWithContacts");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbNewPairs, RootCategory, CollisionsSubCategory, "NewPairs");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbLostPairs, RootCategory, CollisionsSubCategory, "LostPairs");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbNewTouches, RootCategory, CollisionsSubCategory, "NewTouches");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbLostTouches, RootCategory, CollisionsSubCategory, "LostTouches");
-        AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Physics, stats.nbPartitions, RootCategory, CollisionsSubCategory, "Partitions");
+        AZ_PROFILE_DATAPOINT(Physics, ccdPairs, RootCategory, CollisionsSubCategory, "CCDPairs");
+        AZ_PROFILE_DATAPOINT(Physics, modifiedPairs, RootCategory, CollisionsSubCategory, "ModifiedPairs");
+        AZ_PROFILE_DATAPOINT(Physics, triggerPairs, RootCategory, CollisionsSubCategory, "TriggerPairs");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbDiscreteContactPairsTotal, RootCategory, CollisionsSubCategory, "DiscreteContactPairsTotal");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbDiscreteContactPairsWithCacheHits, RootCategory, CollisionsSubCategory, "DiscreteContactPairsWithCacheHits");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbDiscreteContactPairsWithContacts, RootCategory, CollisionsSubCategory, "DiscreteContactPairsWithContacts");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbNewPairs, RootCategory, CollisionsSubCategory, "NewPairs");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbLostPairs, RootCategory, CollisionsSubCategory, "LostPairs");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbNewTouches, RootCategory, CollisionsSubCategory, "NewTouches");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbLostTouches, RootCategory, CollisionsSubCategory, "LostTouches");
+        AZ_PROFILE_DATAPOINT(Physics, stats.nbPartitions, RootCategory, CollisionsSubCategory, "Partitions");
     }
 }
diff --git a/Gems/PhysX/Code/Source/System/PhysXJob.cpp b/Gems/PhysX/Code/Source/System/PhysXJob.cpp
index d65f2b756e..597c8bea98 100644
--- a/Gems/PhysX/Code/Source/System/PhysXJob.cpp
+++ b/Gems/PhysX/Code/Source/System/PhysXJob.cpp
@@ -19,7 +19,7 @@ namespace PhysX
 
     void PhysXJob::Process()
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Physics, m_pxTask.getName());
+        AZ_PROFILE_SCOPE(Physics, m_pxTask.getName());
         m_pxTask.run();
         m_pxTask.release();
     }
diff --git a/Gems/PhysX/Code/Source/System/PhysXSdkCallbacks.cpp b/Gems/PhysX/Code/Source/System/PhysXSdkCallbacks.cpp
index f0182cdbcc..28981722b6 100644
--- a/Gems/PhysX/Code/Source/System/PhysXSdkCallbacks.cpp
+++ b/Gems/PhysX/Code/Source/System/PhysXSdkCallbacks.cpp
@@ -45,11 +45,11 @@ namespace PhysX
     {
         if (!detached)
         {
-            AZ_PROFILE_EVENT_BEGIN(AZ::Debug::ProfileCategory::Physics, eventName);
+            AZ_PROFILE_BEGIN(Physics, eventName);
         }
         else
         {
-            AZ_PROFILE_INTERVAL_START(AZ::Debug::ProfileCategory::Physics, AZ::Crc32(eventName), eventName);
+            AZ_PROFILE_INTERVAL_START(Physics, AZ::Crc32(eventName), eventName);
         }
         return nullptr;
     }
@@ -59,11 +59,11 @@ namespace PhysX
     {
         if (!detached)
         {
-            AZ_PROFILE_EVENT_END(AZ::Debug::ProfileCategory::Physics);
+            AZ_PROFILE_END();
         }
         else
         {
-            AZ_PROFILE_INTERVAL_END(AZ::Debug::ProfileCategory::Physics, AZ::Crc32(eventName));
+            AZ_PROFILE_INTERVAL_END(Physics, AZ::Crc32(eventName));
         }
     }
 }
diff --git a/Gems/PhysX/Code/Source/System/PhysXSystem.cpp b/Gems/PhysX/Code/Source/System/PhysXSystem.cpp
index cc55255e24..ba9cc58011 100644
--- a/Gems/PhysX/Code/Source/System/PhysXSystem.cpp
+++ b/Gems/PhysX/Code/Source/System/PhysXSystem.cpp
@@ -130,7 +130,7 @@ namespace PhysX
 
     void PhysXSystem::Simulate(float deltaTime)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         if (m_state != State::Initialized)
         {
diff --git a/Gems/PhysXDebug/Code/Source/SystemComponent.cpp b/Gems/PhysXDebug/Code/Source/SystemComponent.cpp
index 831a7fdf1d..f9f5d63b2c 100644
--- a/Gems/PhysXDebug/Code/Source/SystemComponent.cpp
+++ b/Gems/PhysXDebug/Code/Source/SystemComponent.cpp
@@ -347,7 +347,7 @@ namespace PhysXDebug
 
     static const physx::PxRenderBuffer& GetRenderBuffer(physx::PxScene* physxScene)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
         PHYSX_SCENE_READ_LOCK(physxScene);
         return physxScene->getRenderBuffer();
     }
@@ -439,7 +439,7 @@ namespace PhysXDebug
             return;
         }
 
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
         m_currentTime = time;
         bool dirty = true;
 
@@ -620,7 +620,7 @@ namespace PhysXDebug
 
     void SystemComponent::ConfigurePhysXVisualizationParameters()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         if (physx::PxScene* physxScene = GetCurrentPxScene())
         {
@@ -667,7 +667,7 @@ namespace PhysXDebug
 
     void SystemComponent::ConfigureCullingBox()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         // Currently using the Cry view camera to support Editor, Game and Launcher modes. This will be updated in due course.
         const AZ::Vector3 cameraTranslation = GetViewCameraPosition();
@@ -694,7 +694,7 @@ namespace PhysXDebug
 
     void SystemComponent::GatherTriangles(const physx::PxRenderBuffer& rb)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
         if (!m_settings.m_visualizationEnabled)
         {
             return;
@@ -728,7 +728,7 @@ namespace PhysXDebug
 
     void SystemComponent::GatherLines(const physx::PxRenderBuffer& rb)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         if (!m_settings.m_visualizationEnabled)
         {
@@ -763,7 +763,7 @@ namespace PhysXDebug
 
     void SystemComponent::GatherJointLimits()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         physx::PxScene* scene = GetCurrentPxScene();
 
@@ -824,7 +824,7 @@ namespace PhysXDebug
 
     void SystemComponent::DrawDebugCullingBox(const AZ::Aabb& cullingBoxAabb)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         if (m_settings.m_visualizationEnabled && m_culling.m_boxWireframe)
         {
@@ -842,7 +842,7 @@ namespace PhysXDebug
 
     AZ::Color SystemComponent::MapOriginalPhysXColorToUserDefinedValues(const physx::PxU32& originalColor)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
 
         // color mapping from PhysX to LY user preference: \PhysX_3.4\Include\common\PxRenderBuffer.h
         switch (static_cast<physx::PxDebugColor::Enum>(originalColor))
@@ -878,7 +878,7 @@ namespace PhysXDebug
 
     void SystemComponent::InitPhysXColorMappings()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Physics);
+        AZ_PROFILE_FUNCTION(Physics);
         m_colorMappings.m_defaultColor.FromU32(physx::PxDebugColor::eARGB_GREEN);
         m_colorMappings.m_black.FromU32(physx::PxDebugColor::eARGB_BLACK);
         m_colorMappings.m_red.FromU32(physx::PxDebugColor::eARGB_RED);
diff --git a/Gems/RADTelemetry/Code/Source/ProfileTelemetryComponent.cpp b/Gems/RADTelemetry/Code/Source/ProfileTelemetryComponent.cpp
index b76d36d189..7e38f76592 100644
--- a/Gems/RADTelemetry/Code/Source/ProfileTelemetryComponent.cpp
+++ b/Gems/RADTelemetry/Code/Source/ProfileTelemetryComponent.cpp
@@ -312,7 +312,7 @@ namespace RADTelemetry
         using MaskType = AZ::Debug::ProfileCategoryPrimitiveType;
 
         // Set all the category bits "below" FirstDetailedCategory and do not enable memory capture by default
-        return (static_cast<MaskType>(1) << static_cast<MaskType>(AZ::Debug::ProfileCategory::FirstDetailedCategory)) - 1;
+        return (static_cast<MaskType>(1) << static_cast<MaskType>(FirstDetailedCategory)) - 1;
     }
 
     AZ::Debug::ProfileCategoryPrimitiveType ProfileTelemetryComponent::GetDefaultCaptureMask()
diff --git a/Gems/RADTelemetry/Code/Source/RADTelemetryModule.cpp b/Gems/RADTelemetry/Code/Source/RADTelemetryModule.cpp
index 56dc8f310a..dc23505833 100644
--- a/Gems/RADTelemetry/Code/Source/RADTelemetryModule.cpp
+++ b/Gems/RADTelemetry/Code/Source/RADTelemetryModule.cpp
@@ -48,7 +48,7 @@ namespace RADTelemetry
         }
 
         // Mask off the memory capture flag and add it back if memory capture is enabled
-        const MaskType fullCaptureMask = (maskCvarValue & ~AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(AZ::Debug::ProfileCategory::MemoryReserved)) | (s_memCaptureEnabled ? AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(AZ::Debug::ProfileCategory::MemoryReserved) : 0);
+        const MaskType fullCaptureMask = (maskCvarValue & ~AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(MemoryReserved)) | (s_memCaptureEnabled ? AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(MemoryReserved) : 0);
         TelemetryRequestBus::Broadcast(&TelemetryRequests::SetCaptureMask, fullCaptureMask);
     }
 
diff --git a/Gems/SceneProcessing/Code/Source/Generation/Components/MeshOptimizer/MeshBuilder.cpp b/Gems/SceneProcessing/Code/Source/Generation/Components/MeshOptimizer/MeshBuilder.cpp
index acbc9ee46e..0f967f644e 100644
--- a/Gems/SceneProcessing/Code/Source/Generation/Components/MeshOptimizer/MeshBuilder.cpp
+++ b/Gems/SceneProcessing/Code/Source/Generation/Components/MeshOptimizer/MeshBuilder.cpp
@@ -250,7 +250,7 @@ namespace AZ::MeshBuilder
             AZ::JobContext* jobContext = nullptr;
             AZ::Job* job = AZ::CreateJobFunction([&subMesh]()
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Animation, "MeshBuilder::GenerateSubMeshVertexOrders::SubMeshJob");
+                AZ_PROFILE_SCOPE(Animation, "MeshBuilder::GenerateSubMeshVertexOrders::SubMeshJob");
                 subMesh->GenerateVertexOrder();
             }, true, jobContext);
 
diff --git a/Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasMemoryAsset.cpp b/Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasMemoryAsset.cpp
index 43ef9b3d3a..e7dc2343f2 100644
--- a/Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasMemoryAsset.cpp
+++ b/Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasMemoryAsset.cpp
@@ -706,7 +706,7 @@ namespace ScriptCanvasEditor
 
                 bool savedSuccess;
                 {
-                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvasAssetHandler::SaveAssetData");
+                    AZ_PROFILE_SCOPE(ScriptCanvas, "ScriptCanvasAssetHandler::SaveAssetData");
 
                     ScriptCanvasMemoryAsset cloneAsset;
                     m_sourceAsset->CloneTo(cloneAsset);
@@ -716,14 +716,14 @@ namespace ScriptCanvasEditor
                 stream.Close();
                 if (savedSuccess)
                 {
-                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "AssetTracker::SaveAssetPostSourceControl : TempToTargetFileReplacement");
+                    AZ_PROFILE_SCOPE(ScriptCanvas, "AssetTracker::SaveAssetPostSourceControl : TempToTargetFileReplacement");
 
                     AZ::IO::FileIOBase* fileIO = AZ::IO::FileIOBase::GetInstance();
                     const bool targetFileExists = fileIO->Exists(m_saveInfo.m_streamName.data());
 
                     bool removedTargetFile;
                     {
-                        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "AssetTracker::SaveAssetPostSourceControl : TempToTargetFileReplacement : RemoveTarget");
+                        AZ_PROFILE_SCOPE(ScriptCanvas, "AssetTracker::SaveAssetPostSourceControl : TempToTargetFileReplacement : RemoveTarget");
                         removedTargetFile = fileIO->Remove(m_saveInfo.m_streamName.data());
                     }
 
@@ -733,7 +733,7 @@ namespace ScriptCanvasEditor
                     }
                     else
                     {
-                        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "AssetTracker::SaveAssetPostSourceControl : TempToTargetFileReplacement : RenameTempFile");
+                        AZ_PROFILE_SCOPE(ScriptCanvas, "AssetTracker::SaveAssetPostSourceControl : TempToTargetFileReplacement : RenameTempFile");
                         AZ::IO::Result renameResult = fileIO->Rename(tempPath.data(), m_saveInfo.m_streamName.data());
                         if (!renameResult)
                         {
diff --git a/Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasUndoHelper.cpp b/Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasUndoHelper.cpp
index 24daf5b2b0..388da67987 100644
--- a/Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasUndoHelper.cpp
+++ b/Gems/ScriptCanvas/Code/Editor/Assets/ScriptCanvasUndoHelper.cpp
@@ -103,7 +103,7 @@ namespace ScriptCanvasEditor
 
     void UndoHelper::Undo()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::ScriptCanvas);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
 
         SceneUndoState* sceneUndoState = m_memoryAsset.GetUndoState();
         if (sceneUndoState)
@@ -123,7 +123,7 @@ namespace ScriptCanvasEditor
 
     void UndoHelper::Redo()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::ScriptCanvas);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
 
         SceneUndoState* sceneUndoState = m_memoryAsset.GetUndoState();
         if (sceneUndoState)
diff --git a/Gems/ScriptCanvas/Code/Editor/Nodes/NodeCreateUtils.cpp b/Gems/ScriptCanvas/Code/Editor/Nodes/NodeCreateUtils.cpp
index 15df6b0261..bb3a28099e 100644
--- a/Gems/ScriptCanvas/Code/Editor/Nodes/NodeCreateUtils.cpp
+++ b/Gems/ScriptCanvas/Code/Editor/Nodes/NodeCreateUtils.cpp
@@ -99,7 +99,7 @@ namespace ScriptCanvasEditor::Nodes
 
     AZStd::pair<ScriptCanvas::Node*, NodeIdPair> CreateAndGetNode(const AZ::Uuid& classId, const ScriptCanvas::ScriptCanvasId& scriptCanvasId, const StyleConfiguration& styleConfiguration, AZStd::function<void(ScriptCanvas::Node*)> onCreateCallback)
     {
-        AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
         NodeIdPair nodeIdPair;
 
         ScriptCanvas::Node* node{};
@@ -134,7 +134,7 @@ namespace ScriptCanvasEditor::Nodes
 
     NodeIdPair CreateObjectMethodNode(AZStd::string_view className, AZStd::string_view methodName, const ScriptCanvas::ScriptCanvasId& scriptCanvasId, ScriptCanvas::PropertyStatus propertyStatus)
     {
-        AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
         NodeIdPair nodeIds;
 
         ScriptCanvas::Node* node = nullptr;
@@ -161,7 +161,7 @@ namespace ScriptCanvasEditor::Nodes
 
     NodeIdPair CreateObjectMethodOverloadNode(AZStd::string_view className, AZStd::string_view methodName, const ScriptCanvas::ScriptCanvasId& scriptCanvasGraphId)
     {
-        AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
         NodeIdPair nodeIds;
 
         ScriptCanvas::Node* node = nullptr;
@@ -188,7 +188,7 @@ namespace ScriptCanvasEditor::Nodes
 
     NodeIdPair CreateGlobalMethodNode(AZStd::string_view methodName, const ScriptCanvas::ScriptCanvasId& scriptCanvasId)
     {
-        AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
         NodeIdPair nodeIds;
 
         ScriptCanvas::Node* node = nullptr;
@@ -215,7 +215,7 @@ namespace ScriptCanvasEditor::Nodes
 
     NodeIdPair CreateEbusWrapperNode(AZStd::string_view busName, const ScriptCanvas::ScriptCanvasId& scriptCanvasId)
     {
-        AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
         NodeIdPair nodeIdPair;
 
         ScriptCanvas::Node* node = nullptr;
@@ -241,7 +241,7 @@ namespace ScriptCanvasEditor::Nodes
     {
         AZ_Assert(assetId.IsValid(), "CreateScriptEventReceiverNode asset Id must be valid");
 
-        AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
         NodeIdPair nodeIdPair;
 
         AZ::Data::Asset<ScriptEvents::ScriptEventsAsset> asset = AZ::Data::AssetManager::Instance().GetAsset<ScriptEvents::ScriptEventsAsset>(assetId, AZ::Data::AssetLoadBehavior::Default);
@@ -276,7 +276,7 @@ namespace ScriptCanvasEditor::Nodes
     {
         AZ_Assert(assetId.IsValid(), "CreateScriptEventSenderNode asset Id must be valid");
 
-        AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
         NodeIdPair nodeIdPair;
 
         AZ::Data::Asset<ScriptEvents::ScriptEventsAsset> asset = AZ::Data::AssetManager::Instance().GetAsset<ScriptEvents::ScriptEventsAsset>(assetId, AZ::Data::AssetLoadBehavior::Default);
@@ -302,7 +302,7 @@ namespace ScriptCanvasEditor::Nodes
 
     NodeIdPair CreateGetVariableNode(const ScriptCanvas::VariableId& variableId, ScriptCanvas::ScriptCanvasId scriptCanvasId)
     {
-        AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
         const AZ::Uuid k_VariableNodeTypeId = azrtti_typeid<ScriptCanvas::Nodes::Core::GetVariableNode>();
 
         NodeIdPair nodeIds;
@@ -333,7 +333,7 @@ namespace ScriptCanvasEditor::Nodes
 
     NodeIdPair CreateSetVariableNode(const ScriptCanvas::VariableId& variableId, ScriptCanvas::ScriptCanvasId scriptCanvasId)
     {
-        AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
         const AZ::Uuid k_VariableNodeTypeId = azrtti_typeid<ScriptCanvas::Nodes::Core::SetVariableNode>();
 
         NodeIdPair nodeIds;
@@ -366,7 +366,7 @@ namespace ScriptCanvasEditor::Nodes
     {
         AZ_Assert(assetId.IsValid(), "CreateFunctionNode source asset Id must be valid");
 
-        AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
         NodeIdPair nodeIdPair;
 
         AZ::Data::Asset<ScriptCanvas::SubgraphInterfaceAsset> asset = AZ::Data::AssetManager::Instance().GetAsset<ScriptCanvas::SubgraphInterfaceAsset>(assetId, AZ::Data::AssetLoadBehavior::PreLoad);
@@ -394,7 +394,7 @@ namespace ScriptCanvasEditor::Nodes
     NodeIdPair CreateAzEventHandlerNode(const AZ::BehaviorMethod& methodWithAzEventReturn, ScriptCanvas::ScriptCanvasId scriptCanvasId,
         AZ::EntityId connectingMethodNodeId)
     {
-        AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
         NodeIdPair nodeIdPair;
 
         // Make sure the method returns an AZ::Event by reference or pointer
diff --git a/Gems/ScriptCanvas/Code/Editor/Nodes/NodeDisplayUtils.cpp b/Gems/ScriptCanvas/Code/Editor/Nodes/NodeDisplayUtils.cpp
index c045a1c0da..65129e4054 100644
--- a/Gems/ScriptCanvas/Code/Editor/Nodes/NodeDisplayUtils.cpp
+++ b/Gems/ScriptCanvas/Code/Editor/Nodes/NodeDisplayUtils.cpp
@@ -57,7 +57,7 @@ namespace ScriptCanvasEditor::Nodes
     // Handles the creation of a node through the node configurations for most nodes.
     AZ::EntityId DisplayGeneralScriptCanvasNode(AZ::EntityId, const ScriptCanvas::Node* node, const NodeConfiguration& nodeConfiguration)
     {
-        AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
 
         AZ::Entity* graphCanvasEntity = nullptr;
 
@@ -445,7 +445,7 @@ namespace ScriptCanvasEditor::Nodes
 
     AZ::EntityId DisplayEbusEventNode(AZ::EntityId, const AZStd::string& busName, const AZStd::string& eventName, const ScriptCanvas::EBusEventId& eventId)
     {
-        AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
 
         AZ::EntityId graphCanvasNodeId;
 
@@ -668,7 +668,7 @@ namespace ScriptCanvasEditor::Nodes
 
     AZ::EntityId DisplayScriptEventNode(AZ::EntityId, const AZ::Data::AssetId assetId, const ScriptEvents::Method& methodDefinition)
     {
-        AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
 
         AZ::EntityId graphCanvasNodeId;
 
@@ -1001,7 +1001,7 @@ namespace ScriptCanvasEditor::Nodes
 
     AZ::EntityId DisplayGetVariableNode(AZ::EntityId graphCanvasGraphId, const ScriptCanvas::Nodes::Core::GetVariableNode* variableNode)
     {
-        AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
 
         NodeConfiguration nodeConfiguration;
         nodeConfiguration.PopulateComponentDescriptors<IconComponent, DynamicSlotComponent, GetVariableNodeDescriptorComponent>();
@@ -1033,7 +1033,7 @@ namespace ScriptCanvasEditor::Nodes
 
     AZ::EntityId DisplaySetVariableNode(AZ::EntityId graphCanvasGraphId, const ScriptCanvas::Nodes::Core::SetVariableNode* variableNode)
     {
-        AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
 
         NodeConfiguration nodeConfiguration;
         nodeConfiguration.PopulateComponentDescriptors<IconComponent, DynamicSlotComponent, SetVariableNodeDescriptorComponent>();
@@ -1069,7 +1069,7 @@ namespace ScriptCanvasEditor::Nodes
 ///////////////////
     AZ::EntityId DisplayScriptCanvasNode(AZ::EntityId graphCanvasGraphId, const ScriptCanvas::Node* node)
     {
-        AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
         AZ::EntityId graphCanvasNodeId;
 
         if (azrtti_istypeof<ScriptCanvas::Nodes::Core::SetVariableNode>(node))
@@ -1122,7 +1122,7 @@ namespace ScriptCanvasEditor::Nodes
 
     static void RegisterAndActivateGraphCanvasSlot(AZ::EntityId graphCanvasNodeId, const ScriptCanvas::SlotId& slotId, AZ::Entity* slotEntity)
     {
-        AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
         if (slotEntity)
         {
             slotEntity->Init();
@@ -1166,7 +1166,7 @@ namespace ScriptCanvasEditor::Nodes
             return AZ::EntityId();
         }
 
-        AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
         AZ::Entity* slotEntity = nullptr;
 
         AZ::Uuid typeId = ScriptCanvas::Data::ToAZType(slot.GetDataType());
@@ -1258,7 +1258,7 @@ namespace ScriptCanvasEditor::Nodes::SlotDisplayHelper
 {
     AZ::EntityId DisplayPropertySlot(AZ::EntityId graphCanvasNodeId, const ScriptCanvas::VisualExtensionSlotConfiguration& propertyConfiguration)
     {
-        AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
 
         GraphCanvas::SlotConfiguration graphCanvasConfiguration;
 
@@ -1284,7 +1284,7 @@ namespace ScriptCanvasEditor::Nodes::SlotDisplayHelper
 
     AZ::EntityId DisplayExtendableSlot(AZ::EntityId graphCanvasNodeId, const ScriptCanvas::VisualExtensionSlotConfiguration& extenderConfiguration)
     {
-        AZ_PROFILE_TIMER("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
 
         GraphCanvas::ExtenderSlotConfiguration graphCanvasConfiguration;
 
diff --git a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/EBusHandler.cpp b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/EBusHandler.cpp
index d878415341..bd19482dd8 100644
--- a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/EBusHandler.cpp
+++ b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/EBusHandler.cpp
@@ -115,7 +115,7 @@ namespace ScriptCanvas
     void EBusHandler::OnEventGenericHook(void* userData, const char* eventName, int eventIndex, AZ::BehaviorValueParameter* result, int numParameters, AZ::BehaviorValueParameter* parameters)
     {
         AZ_UNUSED(eventName);
-        AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::ScriptCanvas, "EBusEventHandler::OnEvent %s", eventName);
+        AZ_PROFILE_SCOPE(ScriptCanvas, "EBusEventHandler::OnEvent %s", eventName);
         auto handler = reinterpret_cast<EBusHandler*>(userData);
         SCRIPT_CANVAS_PERFORMANCE_SCOPE_LATENT(handler->GetScriptCanvasId(), handler->GetAssetId());
         handler->OnEvent(nullptr, eventIndex, result, numParameters, parameters);
diff --git a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Node.cpp b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Node.cpp
index 6e87e52f87..5aac3715eb 100644
--- a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Node.cpp
+++ b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Core/Node.cpp
@@ -1022,7 +1022,7 @@ namespace ScriptCanvas
 
     void Node::SetToDefaultValueOfType(const SlotId& slotId)
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::Node::SetToDefaultValueOfType");
+        AZ_PROFILE_SCOPE(ScriptCanvas, "ScriptCanvas::Node::SetToDefaultValueOfType");
 
         Slot* slot = GetSlot(slotId);
 
@@ -1616,7 +1616,7 @@ namespace ScriptCanvas
 
     Data::Type Node::GetSlotDataType(const SlotId& slotId) const
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::Node::GetSlotDataType");
+        AZ_PROFILE_SCOPE(ScriptCanvas, "ScriptCanvas::Node::GetSlotDataType");
 
         const auto* slot = GetSlot(slotId);
 
@@ -1631,7 +1631,7 @@ namespace ScriptCanvas
 
     VariableId Node::GetSlotVariableId(const SlotId& slotId) const
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::Node::GetSlotVariableId");
+        AZ_PROFILE_SCOPE(ScriptCanvas, "ScriptCanvas::Node::GetSlotVariableId");
 
         Slot* slot = GetSlot(slotId);
 
@@ -1645,7 +1645,7 @@ namespace ScriptCanvas
 
     void Node::SetSlotVariableId(const SlotId& slotId, const VariableId& variableId)
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::Node::SetSlotVariableId");
+        AZ_PROFILE_SCOPE(ScriptCanvas, "ScriptCanvas::Node::SetSlotVariableId");
 
         Slot* slot = GetSlot(slotId);
 
@@ -1664,7 +1664,7 @@ namespace ScriptCanvas
 
     void Node::ClearSlotVariableId(const SlotId& slotId)
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::Node::ResetSlotVariableId");
+        AZ_PROFILE_SCOPE(ScriptCanvas, "ScriptCanvas::Node::ResetSlotVariableId");
 
         SetSlotVariableId(slotId, VariableId());
     }
@@ -1861,7 +1861,7 @@ namespace ScriptCanvas
 
     AZStd::vector<const Slot*> Node::GetAllSlotsByDescriptor(const SlotDescriptor& slotDescriptor, bool allowLatentSlots) const
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::Node::GetSlotsByType");
+        AZ_PROFILE_SCOPE(ScriptCanvas, "ScriptCanvas::Node::GetSlotsByType");
 
         AZStd::vector<const Slot*> slots;
 
@@ -1879,7 +1879,7 @@ namespace ScriptCanvas
 
     AZStd::vector<Endpoint> Node::GetAllEndpointsByDescriptor(const SlotDescriptor& slotDescriptor, bool allowLatentSlots) const
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::Node::GetEndpointsByType");
+        AZ_PROFILE_SCOPE(ScriptCanvas, "ScriptCanvas::Node::GetEndpointsByType");
 
         AZStd::vector<Endpoint> endpoints;
 
@@ -1898,7 +1898,7 @@ namespace ScriptCanvas
 
     AZStd::vector<SlotId> Node::GetSlotIds(AZStd::string_view slotName) const
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::Node::GetSlotIds");
+        AZ_PROFILE_SCOPE(ScriptCanvas, "ScriptCanvas::Node::GetSlotIds");
 
         auto nameSlotRange = m_slotNameMap.equal_range(slotName);
         AZStd::vector<SlotId> result;
@@ -1911,7 +1911,7 @@ namespace ScriptCanvas
 
     Slot* Node::GetSlot(const SlotId& slotId) const
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::Node::GetSlot");
+        AZ_PROFILE_SCOPE(ScriptCanvas, "ScriptCanvas::Node::GetSlot");
 
         if (slotId.IsValid())
         {
@@ -1994,7 +1994,7 @@ namespace ScriptCanvas
 
     AZStd::vector<const Slot*> Node::GetAllSlots() const
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::Node::GetAllSlots");
+        AZ_PROFILE_SCOPE(ScriptCanvas, "ScriptCanvas::Node::GetAllSlots");
 
         const SlotList& slots = GetSlots();
 
@@ -2011,7 +2011,7 @@ namespace ScriptCanvas
 
     AZStd::vector<Slot*> Node::ModAllSlots()
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::Node::ModAllSlots");
+        AZ_PROFILE_SCOPE(ScriptCanvas, "ScriptCanvas::Node::ModAllSlots");
 
         SlotList& slots = GetSlots();
 
@@ -2408,7 +2408,7 @@ namespace ScriptCanvas
 
     NodePtrConstList Node::FindConnectedNodesByDescriptor(const SlotDescriptor& slotDescriptor, bool followLatentConnections) const
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::Node::GetConnectedNodesByType");
+        AZ_PROFILE_SCOPE(ScriptCanvas, "ScriptCanvas::Node::GetConnectedNodesByType");
 
         NodePtrConstList connectedNodes;
 
@@ -2427,7 +2427,7 @@ namespace ScriptCanvas
 
     AZStd::vector<AZStd::pair<const Node*, SlotId>> Node::FindConnectedNodesAndSlotsByDescriptor(const SlotDescriptor& slotDescriptor, bool followLatentConnections) const
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::Node::GetConnectedNodesAndSlotsByType");
+        AZ_PROFILE_SCOPE(ScriptCanvas, "ScriptCanvas::Node::GetConnectedNodesAndSlotsByType");
 
         AZStd::vector<AZStd::pair<const Node*, SlotId>> connectedNodes;
 
@@ -2593,7 +2593,7 @@ namespace ScriptCanvas
 
     void Node::OnDatumEdited(const Datum* datum)
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::Node::OnDatumChanged");
+        AZ_PROFILE_SCOPE(ScriptCanvas, "ScriptCanvas::Node::OnDatumChanged");
 
         SlotId slotId;
 
@@ -2788,7 +2788,7 @@ namespace ScriptCanvas
 
     SlotId Node::FindSlotIdForDescriptor(AZStd::string_view slotName, const SlotDescriptor& descriptor) const
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::Node::FindSlotIdForDescriptor");
+        AZ_PROFILE_SCOPE(ScriptCanvas, "ScriptCanvas::Node::FindSlotIdForDescriptor");
 
         auto slotNameRange = m_slotNameMap.equal_range(slotName);
         auto nameSlotIt = AZStd::find_if(slotNameRange.first, slotNameRange.second, [descriptor](const AZStd::pair<AZStd::string, SlotIterator>& nameSlotPair)
@@ -2801,7 +2801,7 @@ namespace ScriptCanvas
 
     int Node::FindSlotIndex(const SlotId& slotId) const
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::Node::FindSlotIndex");
+        AZ_PROFILE_SCOPE(ScriptCanvas, "ScriptCanvas::Node::FindSlotIndex");
 
         auto slotIdIter = m_slotIdIteratorCache.find(slotId);
 
@@ -2816,7 +2816,7 @@ namespace ScriptCanvas
 
     bool Node::IsConnected(const Slot& slot) const
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::Node::IsConnected");
+        AZ_PROFILE_SCOPE(ScriptCanvas, "ScriptCanvas::Node::IsConnected");
         return slot.IsVariableReference() || m_graphRequestBus->IsEndpointConnected(slot.GetEndpoint());
     }
 
@@ -2862,7 +2862,7 @@ namespace ScriptCanvas
     
     EndpointsResolved Node::GetConnectedNodes(const Slot& slot) const
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::Node::GetConnectedNodes");
+        AZ_PROFILE_SCOPE(ScriptCanvas, "ScriptCanvas::Node::GetConnectedNodes");
 
         EndpointsResolved connectedNodes;
 
@@ -2906,7 +2906,7 @@ namespace ScriptCanvas
 
     AZStd::vector<AZStd::pair<Node*, const SlotId>> Node::ModConnectedNodes(const Slot& slot) const
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::Node::ModConnectedNodes");
+        AZ_PROFILE_SCOPE(ScriptCanvas, "ScriptCanvas::Node::ModConnectedNodes");
         AZStd::vector<AZStd::pair<Node*, const SlotId>> connectedNodes;
         ModConnectedNodes(slot, connectedNodes);
         return connectedNodes;
@@ -3481,7 +3481,7 @@ namespace ScriptCanvas
 
     AZStd::vector<const Slot*> Node::GetSlotsByType(CombinedSlotType slotType) const
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::Node::GetSlotsByType");
+        AZ_PROFILE_SCOPE(ScriptCanvas, "ScriptCanvas::Node::GetSlotsByType");
 
         AZStd::vector<const Slot*> slots;
 
diff --git a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Execution/RuntimeComponent.cpp b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Execution/RuntimeComponent.cpp
index ac19028fd5..89c69ee4c5 100644
--- a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Execution/RuntimeComponent.cpp
+++ b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Execution/RuntimeComponent.cpp
@@ -61,7 +61,7 @@ namespace ScriptCanvas
 
     void RuntimeComponent::Execute()
     {
-        AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::ScriptCanvas, "RuntimeComponent::Execute (%s)", m_runtimeOverrides.m_runtimeAsset.GetId().ToString<AZStd::string>().c_str());
+        AZ_PROFILE_SCOPE(ScriptCanvas, "RuntimeComponent::Execute (%s)", m_runtimeOverrides.m_runtimeAsset.GetId().ToString<AZStd::string>().c_str());
         AZ_Assert(m_executionState, "RuntimeComponent::Execute called without an execution state");
         SC_EXECUTION_TRACE_GRAPH_ACTIVATED(CreateActivationInfo());
         SCRIPT_CANVAS_PERFORMANCE_SCOPE_EXECUTION(m_executionState->GetScriptCanvasId(), m_runtimeOverrides.m_runtimeAsset.GetId());
@@ -117,7 +117,7 @@ namespace ScriptCanvas
         AZ_Assert(m_runtimeAsset.Get(), "RuntimeComponent::m_runtimeAsset AssetId: %s was valid, but the data was not pre-loaded, so this script will not run", m_runtimeOverrides.m_runtimeAsset.GetId().ToString<AZStd::string>().data());
 #endif
 
-        AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::ScriptCanvas, "RuntimeComponent::InitializeExecution (%s)", m_runtimeOverrides.m_runtimeAsset.GetId().ToString<AZStd::string>().c_str());
+        AZ_PROFILE_SCOPE(ScriptCanvas, "RuntimeComponent::InitializeExecution (%s)", m_runtimeOverrides.m_runtimeAsset.GetId().ToString<AZStd::string>().c_str());
         SCRIPT_CANVAS_PERFORMANCE_SCOPE_INITIALIZATION(m_scriptCanvasId, m_runtimeOverrides.m_runtimeAsset.GetId());
         m_executionState = ExecutionState::Create(ExecutionStateConfig(m_runtimeOverrides.m_runtimeAsset, *this));
 
diff --git a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Internal/Nodeables/BaseTimer.cpp b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Internal/Nodeables/BaseTimer.cpp
index 8c8eac5e1b..d6454ef4a4 100644
--- a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Internal/Nodeables/BaseTimer.cpp
+++ b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Internal/Nodeables/BaseTimer.cpp
@@ -46,7 +46,7 @@ namespace ScriptCanvas
 
             void BaseTimer::OnTick(float delta, AZ::ScriptTimePoint)
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::ScriptCanvas);
+                AZ_PROFILE_FUNCTION(ScriptCanvas);
                 SCRIPT_CANVAS_PERFORMANCE_SCOPE_LATENT(GetScriptCanvasId(), GetAssetId());
 
                 switch (m_timeUnits)
diff --git a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Internal/Nodes/StringFormatted.cpp b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Internal/Nodes/StringFormatted.cpp
index b2741f4498..552e04a850 100644
--- a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Internal/Nodes/StringFormatted.cpp
+++ b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Internal/Nodes/StringFormatted.cpp
@@ -191,7 +191,7 @@ namespace ScriptCanvas
 
             AZStd::string StringFormatted::ProcessFormat()
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::ScriptCanvas, "ScriptCanvas::StringFormatted::ProcessFormat");
+                AZ_PROFILE_SCOPE(ScriptCanvas, "ScriptCanvas::StringFormatted::ProcessFormat");
 
                 AZStd::string text;
 
diff --git a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Operators/Math/OperatorMul.cpp b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Operators/Math/OperatorMul.cpp
index abbb4d8b6c..06ccb617ff 100644
--- a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Operators/Math/OperatorMul.cpp
+++ b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Operators/Math/OperatorMul.cpp
@@ -58,7 +58,7 @@ namespace ScriptCanvas
 
             void OperatorMul::Operator(Data::eType type, const ArithmeticOperands& operands, Datum& result)
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::ScriptCanvas);
+                AZ_PROFILE_FUNCTION(ScriptCanvas);
 
                 switch (type)
                 {
diff --git a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Time/DelayNodeable.cpp b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Time/DelayNodeable.cpp
index 168b6d825a..c7842f28fd 100644
--- a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Time/DelayNodeable.cpp
+++ b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Time/DelayNodeable.cpp
@@ -49,7 +49,7 @@ namespace ScriptCanvas
 
             void DelayNodeable::OnTick(float deltaTime, [[maybe_unused]] AZ::ScriptTimePoint time)
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::ScriptCanvas);
+                AZ_PROFILE_FUNCTION(ScriptCanvas);
                 SCRIPT_CANVAS_PERFORMANCE_SCOPE_LATENT(GetScriptCanvasId(), GetAssetId());
                 m_currentTime -= static_cast<float>(deltaTime);
                 if (m_currentTime <= 0.f)
diff --git a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Time/DurationNodeable.cpp b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Time/DurationNodeable.cpp
index 942271ad3a..f7f08874db 100644
--- a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Time/DurationNodeable.cpp
+++ b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Time/DurationNodeable.cpp
@@ -28,7 +28,7 @@ namespace ScriptCanvas
 
             void DurationNodeable::OnTick(float deltaTime, [[maybe_unused]] AZ::ScriptTimePoint time)
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::ScriptCanvas);
+                AZ_PROFILE_FUNCTION(ScriptCanvas);
                 SCRIPT_CANVAS_PERFORMANCE_SCOPE_LATENT(GetScriptCanvasId(), GetAssetId());
 
                 if (m_elapsedTime <= m_duration)
diff --git a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Time/TimerNodeable.cpp b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Time/TimerNodeable.cpp
index db50f66f35..37d4d026c1 100644
--- a/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Time/TimerNodeable.cpp
+++ b/Gems/ScriptCanvas/Code/Include/ScriptCanvas/Libraries/Time/TimerNodeable.cpp
@@ -16,7 +16,7 @@ namespace ScriptCanvas
         {
             void TimerNodeable::OnTick(float /*deltaTime*/, AZ::ScriptTimePoint time)
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::ScriptCanvas);
+                AZ_PROFILE_FUNCTION(ScriptCanvas);
                 SCRIPT_CANVAS_PERFORMANCE_SCOPE_LATENT(GetScriptCanvasId(), GetAssetId());
                 double milliseconds = time.GetMilliseconds() - m_start.GetMilliseconds();
                 double seconds = time.GetSeconds() - m_start.GetSeconds();
diff --git a/Gems/SurfaceData/Code/Include/SurfaceData/Utility/SurfaceDataUtility.h b/Gems/SurfaceData/Code/Include/SurfaceData/Utility/SurfaceDataUtility.h
index 18899ac3b1..c72f725a07 100644
--- a/Gems/SurfaceData/Code/Include/SurfaceData/Utility/SurfaceDataUtility.h
+++ b/Gems/SurfaceData/Code/Include/SurfaceData/Utility/SurfaceDataUtility.h
@@ -9,6 +9,7 @@
 #pragma once
 
 #include <SurfaceData/SurfaceDataTypes.h>
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/Math/MathUtils.h>
 #include <AzCore/Math/IntersectSegment.h>
 #include <AzCore/Math/Transform.h>
@@ -33,7 +34,7 @@ namespace SurfaceData
         AZ::Vector3& outPosition,
         AZ::Vector3& outNormal)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         const size_t vertexCount = vertices.size();
         if (vertexCount > 0 && vertexCount % 4 == 0)
diff --git a/Gems/SurfaceData/Code/Source/Components/SurfaceDataColliderComponent.cpp b/Gems/SurfaceData/Code/Source/Components/SurfaceDataColliderComponent.cpp
index 22328fc73f..eef9179194 100644
--- a/Gems/SurfaceData/Code/Source/Components/SurfaceDataColliderComponent.cpp
+++ b/Gems/SurfaceData/Code/Source/Components/SurfaceDataColliderComponent.cpp
@@ -184,7 +184,7 @@ namespace SurfaceData
 
     bool SurfaceDataColliderComponent::DoRayTrace(const AZ::Vector3& inPosition, bool queryPointOnly, AZ::Vector3& outPosition, AZ::Vector3& outNormal) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::lock_guard<decltype(m_cacheMutex)> lock(m_cacheMutex);
 
@@ -249,7 +249,7 @@ namespace SurfaceData
 
     void SurfaceDataColliderComponent::ModifySurfacePoints(SurfacePointList& surfacePointList) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::lock_guard<decltype(m_cacheMutex)> lock(m_cacheMutex);
 
@@ -303,7 +303,7 @@ namespace SurfaceData
 
     void SurfaceDataColliderComponent::UpdateColliderData()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         bool colliderValidBeforeUpdate = false;
         bool colliderValidAfterUpdate = false;
diff --git a/Gems/SurfaceData/Code/Source/Components/SurfaceDataShapeComponent.cpp b/Gems/SurfaceData/Code/Source/Components/SurfaceDataShapeComponent.cpp
index 6129094115..890f8fba54 100644
--- a/Gems/SurfaceData/Code/Source/Components/SurfaceDataShapeComponent.cpp
+++ b/Gems/SurfaceData/Code/Source/Components/SurfaceDataShapeComponent.cpp
@@ -143,7 +143,7 @@ namespace SurfaceData
 
     void SurfaceDataShapeComponent::GetSurfacePoints(const AZ::Vector3& inPosition, SurfacePointList& surfacePointList) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::lock_guard<decltype(m_cacheMutex)> lock(m_cacheMutex);
 
@@ -168,7 +168,7 @@ namespace SurfaceData
 
     void SurfaceDataShapeComponent::ModifySurfacePoints(SurfacePointList& surfacePointList) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::lock_guard<decltype(m_cacheMutex)> lock(m_cacheMutex);
 
@@ -221,7 +221,7 @@ namespace SurfaceData
 
     void SurfaceDataShapeComponent::UpdateShapeData()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         bool shapeValidBeforeUpdate = false;
         bool shapeValidAfterUpdate = false;
diff --git a/Gems/SurfaceData/Code/Source/SurfaceDataSystemComponent.cpp b/Gems/SurfaceData/Code/Source/SurfaceDataSystemComponent.cpp
index 356785df35..7638b6720e 100644
--- a/Gems/SurfaceData/Code/Source/SurfaceDataSystemComponent.cpp
+++ b/Gems/SurfaceData/Code/Source/SurfaceDataSystemComponent.cpp
@@ -6,6 +6,7 @@
  *
  */
 
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/RTTI/BehaviorContext.h>
 #include <AzCore/Serialization/SerializeContext.h>
 #include <AzCore/Serialization/EditContext.h>
@@ -180,7 +181,7 @@ namespace SurfaceData
 
     void SurfaceDataSystemComponent::GetSurfacePoints(const AZ::Vector3& inPosition, const SurfaceTagVector& desiredTags, SurfacePointList& surfacePointList) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         const bool hasDesiredTags = HasValidTags(desiredTags);
         const bool hasModifierTags = hasDesiredTags && HasMatchingTags(desiredTags, m_registeredModifierTags);
@@ -228,7 +229,7 @@ namespace SurfaceData
 
     void SurfaceDataSystemComponent::GetSurfacePointsFromRegion(const AZ::Aabb& inRegion, const AZ::Vector2 stepSize, const SurfaceTagVector& desiredTags, SurfacePointListPerPosition& surfacePointListPerPosition) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::lock_guard<decltype(m_registrationMutex)> registrationLock(m_registrationMutex);
 
@@ -317,7 +318,7 @@ namespace SurfaceData
 
     void SurfaceDataSystemComponent::CombineSortAndFilterNeighboringPoints(SurfacePointList& sourcePointList, bool hasDesiredTags, const SurfaceTagVector& desiredTags) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         if (sourcePointList.empty())
         {
diff --git a/Gems/SurfaceData/Code/Source/SurfaceDataUtility.cpp b/Gems/SurfaceData/Code/Source/SurfaceDataUtility.cpp
index d55f79faea..ba21d0a616 100644
--- a/Gems/SurfaceData/Code/Source/SurfaceDataUtility.cpp
+++ b/Gems/SurfaceData/Code/Source/SurfaceDataUtility.cpp
@@ -17,7 +17,7 @@ namespace SurfaceData
         const AZ::Vector3& rayStart, const AZ::Vector3& rayEnd, 
         AZ::Vector3& outPosition, AZ::Vector3& outNormal)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         const AZ::Vector3 clampedScale = nonUniformScale.GetMax(AZ::Vector3(AZ::MinTransformScale));
 
diff --git a/Gems/SurfaceData/Code/Source/SurfaceTag.cpp b/Gems/SurfaceData/Code/Source/SurfaceTag.cpp
index 70a2669b19..f986509140 100644
--- a/Gems/SurfaceData/Code/Source/SurfaceTag.cpp
+++ b/Gems/SurfaceData/Code/Source/SurfaceTag.cpp
@@ -88,7 +88,7 @@ namespace SurfaceData
 
     AZStd::vector<AZStd::pair<AZ::u32, AZStd::string>> SurfaceTag::GetRegisteredTags()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         SurfaceTagNameSet labels;
         SurfaceDataTagProviderRequestBus::Broadcast(&SurfaceDataTagProviderRequestBus::Events::GetRegisteredSurfaceTagNames, labels);
@@ -134,7 +134,7 @@ namespace SurfaceData
 
     AZStd::vector<AZStd::pair<AZ::u32, AZStd::string>> SurfaceTag::BuildSelectableTagList() const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::vector<AZStd::pair<AZ::u32, AZStd::string>> selectableTags = GetRegisteredTags();
 
@@ -152,7 +152,7 @@ namespace SurfaceData
 
     AZStd::string SurfaceTag::GetDisplayName() const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::string name;
         FindDisplayName(GetRegisteredTags(), name);
diff --git a/Gems/Vegetation/Code/Source/AreaSystemComponent.cpp b/Gems/Vegetation/Code/Source/AreaSystemComponent.cpp
index 7ce1a2c0a3..4ffed260de 100644
--- a/Gems/Vegetation/Code/Source/AreaSystemComponent.cpp
+++ b/Gems/Vegetation/Code/Source/AreaSystemComponent.cpp
@@ -617,7 +617,7 @@ namespace Vegetation
 
     void AreaSystemComponent::EnumerateInstancesInOverlappingSectors(const AZ::Aabb& bounds, AreaSystemEnumerateCallback callback) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         if (!bounds.IsValid())
         {
@@ -644,7 +644,7 @@ namespace Vegetation
 
     void AreaSystemComponent::EnumerateInstancesInAabb(const AZ::Aabb& bounds, AreaSystemEnumerateCallback callback) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         if (!bounds.IsValid())
         {
@@ -723,7 +723,7 @@ namespace Vegetation
 
     void AreaSystemComponent::OnTick(float deltaTime, [[maybe_unused]] AZ::ScriptTimePoint time)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         if (m_configuration.m_sectorSizeInMeters < 0)
         {
@@ -792,7 +792,7 @@ namespace Vegetation
                     m_threadData.m_vegetationThreadState = PersistentThreadData::VegetationThreadState::Running;
                     auto job = AZ::CreateJobFunction([this]()
                     {
-                        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Entity, "Vegetation::AreaSystemComponent::VegetationThread");
+                        AZ_PROFILE_SCOPE(Entity, "Vegetation::AreaSystemComponent::VegetationThread");
 
                         UpdateContext context;
                         context.Run(&m_threadData, &m_vegTasks, &m_cachedMainThreadData);
@@ -830,7 +830,7 @@ namespace Vegetation
 
     bool AreaSystemComponent::CalculateViewRect()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         //Get the active camera.
         bool cameraPositionIsValid = false;
@@ -983,7 +983,7 @@ namespace Vegetation
 
     void AreaSystemComponent::OnSystemEvent(ESystemEvent event, [[maybe_unused]] UINT_PTR wparam, [[maybe_unused]] UINT_PTR lparam)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         switch (event)
         {
@@ -1016,7 +1016,7 @@ namespace Vegetation
 
     void AreaSystemComponent::VegetationThreadTasks::ProcessVegetationThreadTasks(UpdateContext* context, PersistentThreadData* threadData)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         VegetationThreadTasks::VegetationThreadTaskList tasks;
         {
@@ -1056,7 +1056,7 @@ namespace Vegetation
 
     const AreaSystemComponent::SectorInfo* AreaSystemComponent::VegetationThreadTasks::GetSector(const SectorId& sectorId) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::lock_guard<decltype(m_sectorRollingWindowMutex)> lock(m_sectorRollingWindowMutex);
         auto itSector = m_sectorRollingWindow.find(sectorId);
@@ -1065,7 +1065,7 @@ namespace Vegetation
 
     AreaSystemComponent::SectorInfo* AreaSystemComponent::VegetationThreadTasks::GetSector(const SectorId& sectorId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::lock_guard<decltype(m_sectorRollingWindowMutex)> lock(m_sectorRollingWindowMutex);
         auto itSector = m_sectorRollingWindow.find(sectorId);
@@ -1074,7 +1074,7 @@ namespace Vegetation
 
     AreaSystemComponent::SectorInfo* AreaSystemComponent::VegetationThreadTasks::CreateSector(const SectorId& sectorId, int sectorDensity, int sectorSizeInMeters, SnapMode sectorPointSnapMode)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         SectorInfo sectorInfo;
         sectorInfo.m_id = sectorId;
@@ -1089,7 +1089,7 @@ namespace Vegetation
 
     void AreaSystemComponent::VegetationThreadTasks::UpdateSectorPoints(SectorInfo& sectorInfo, int sectorDensity, int sectorSizeInMeters, SnapMode sectorPointSnapMode)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
         const float vegStep = sectorSizeInMeters / static_cast<float>(sectorDensity);
 
         //build a free list of all points in the sector for areas to consume
@@ -1190,7 +1190,7 @@ namespace Vegetation
 
     void AreaSystemComponent::VegetationThreadTasks::DeleteSector(const SectorId& sectorId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::lock_guard<decltype(m_sectorRollingWindowMutex)> lock(m_sectorRollingWindowMutex);
         auto itSector = m_sectorRollingWindow.find(sectorId);
@@ -1249,7 +1249,7 @@ namespace Vegetation
 
     void AreaSystemComponent::VegetationThreadTasks::ReleaseUnregisteredClaims(SectorInfo& sectorInfo)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         if (!m_unregisteredVegetationAreaSet.empty())
         {
@@ -1275,7 +1275,7 @@ namespace Vegetation
 
     void AreaSystemComponent::VegetationThreadTasks::ReleaseUnusedClaims(SectorInfo& sectorInfo)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::unordered_map<AZ::EntityId, AZStd::unordered_set<ClaimHandle>> claimsToRelease;
 
@@ -1310,7 +1310,7 @@ namespace Vegetation
 
     void AreaSystemComponent::VegetationThreadTasks::FillSector(SectorInfo& sectorInfo, const VegetationAreaVector& activeAreas)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
         VEG_PROFILE_METHOD(DebugNotificationBus::TryQueueBroadcast(&DebugNotificationBus::Events::FillSectorStart, sectorInfo.GetSectorX(), sectorInfo.GetSectorY(), AZStd::chrono::system_clock::now()));
 
         ReleaseUnregisteredClaims(sectorInfo);
@@ -1352,7 +1352,7 @@ namespace Vegetation
 
     void AreaSystemComponent::VegetationThreadTasks::EmptySector(SectorInfo& sectorInfo)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::unordered_map<AZ::EntityId, AZStd::unordered_set<ClaimHandle>> claimsToRelease;
 
@@ -1384,7 +1384,7 @@ namespace Vegetation
 
     void AreaSystemComponent::VegetationThreadTasks::ClearSectors()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::lock_guard<decltype(m_sectorRollingWindowMutex)> lock(m_sectorRollingWindowMutex);
         for (auto& sectorPair : m_sectorRollingWindow)
@@ -1399,13 +1399,13 @@ namespace Vegetation
 
     void AreaSystemComponent::VegetationThreadTasks::CreateClaim(SectorInfo& sectorInfo, const ClaimHandle handle, const InstanceData& instanceData)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
         sectorInfo.m_claimedWorldPoints[handle] = instanceData;
     }
 
     ClaimHandle AreaSystemComponent::VegetationThreadTasks::CreateClaimHandle(const SectorInfo& sectorInfo, uint32_t index) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         ClaimHandle handle = 0;
         AreaSystemUtil::hash_combine_64(handle, sectorInfo.m_id.first);
@@ -1456,7 +1456,7 @@ namespace Vegetation
 
     void AreaSystemComponent::UpdateContext::Run(PersistentThreadData* threadData, VegetationThreadTasks* vegTasks, CachedMainThreadData* cachedMainThreadData)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         // Ensure that the main thread doesn't activate or deactivate the component until after this thread finishes.
         // Note that this does *not* prevent the main thread from running OnTick, which can communicate data changes
@@ -1466,7 +1466,7 @@ namespace Vegetation
         bool keepProcessing = true;
         while (keepProcessing && (threadData->m_vegetationThreadState != PersistentThreadData::VegetationThreadState::InterruptRequested))
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::Entity, "Vegetation::AreaSystemComponent::UpdateContext::Run-InnerLoop");
+            AZ_PROFILE_SCOPE(Entity, "Vegetation::AreaSystemComponent::UpdateContext::Run-InnerLoop");
             // Update thread state if its dirty
             PersistentThreadData::VegetationDataSyncState expected = PersistentThreadData::VegetationDataSyncState::Dirty;
             if (threadData->m_vegetationDataSyncState.compare_exchange_strong(expected, PersistentThreadData::VegetationDataSyncState::Updating))
@@ -1501,7 +1501,7 @@ namespace Vegetation
 
     void AreaSystemComponent::UpdateContext::UpdateActiveVegetationAreas(PersistentThreadData* threadData, const ViewRect& viewRect)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         //build a priority sorted list of all active areas
         if (threadData->m_activeAreasDirty)
@@ -1553,7 +1553,7 @@ namespace Vegetation
 
     bool AreaSystemComponent::UpdateContext::UpdateSectorWorkLists(PersistentThreadData* threadData, VegetationThreadTasks* vegTasks)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         auto& worldToSector = m_cachedMainThreadData.m_worldToSector;
         auto& currViewRect = m_cachedMainThreadData.m_currViewRect;
@@ -1761,7 +1761,7 @@ namespace Vegetation
 
     bool AreaSystemComponent::UpdateContext::UpdateOneSector(PersistentThreadData* threadData, VegetationThreadTasks* vegTasks)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         // This chooses work in the following order:
         // 1) Delete if we have more sectors than the total that should be in the view rectangle
diff --git a/Gems/Vegetation/Code/Source/Components/AreaBlenderComponent.cpp b/Gems/Vegetation/Code/Source/Components/AreaBlenderComponent.cpp
index d31a6be69d..8bf48de58e 100644
--- a/Gems/Vegetation/Code/Source/Components/AreaBlenderComponent.cpp
+++ b/Gems/Vegetation/Code/Source/Components/AreaBlenderComponent.cpp
@@ -220,7 +220,7 @@ namespace Vegetation
 
     bool AreaBlenderComponent::PrepareToClaim(EntityIdStack& stackIds)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         bool result = true;
 
@@ -257,7 +257,7 @@ namespace Vegetation
 
     void AreaBlenderComponent::ClaimPositions(EntityIdStack& stackIds, ClaimContext& context)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         if (context.m_availablePoints.empty())
         {
@@ -293,7 +293,7 @@ namespace Vegetation
 
     void AreaBlenderComponent::UnclaimPosition(const ClaimHandle handle)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZ_WarningOnce("Vegetation", !m_isRequestInProgress, "Detected cyclic dependences with vegetation entity references");
         if (!m_isRequestInProgress)
@@ -311,7 +311,7 @@ namespace Vegetation
 
     AZ::Aabb AreaBlenderComponent::GetEncompassingAabb() const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZ::Aabb bounds = AZ::Aabb::CreateNull();
 
@@ -340,7 +340,7 @@ namespace Vegetation
 
     AZ::u32 AreaBlenderComponent::GetProductCount() const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZ::u32 count = 0;
 
diff --git a/Gems/Vegetation/Code/Source/Components/AreaComponentBase.cpp b/Gems/Vegetation/Code/Source/Components/AreaComponentBase.cpp
index 6e87154e5b..6a9060c6d4 100644
--- a/Gems/Vegetation/Code/Source/Components/AreaComponentBase.cpp
+++ b/Gems/Vegetation/Code/Source/Components/AreaComponentBase.cpp
@@ -279,13 +279,13 @@ namespace Vegetation
 
     void AreaComponentBase::OnTransformChanged(const AZ::Transform& /*local*/, const AZ::Transform& /*world*/)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
         OnCompositionChanged();
     }
 
     void AreaComponentBase::OnShapeChanged([[maybe_unused]] ShapeComponentNotifications::ShapeChangeReasons reasons)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
         OnCompositionChanged();
     }
 }
diff --git a/Gems/Vegetation/Code/Source/Components/BlockerComponent.cpp b/Gems/Vegetation/Code/Source/Components/BlockerComponent.cpp
index d980f7e45a..e26f1aee47 100644
--- a/Gems/Vegetation/Code/Source/Components/BlockerComponent.cpp
+++ b/Gems/Vegetation/Code/Source/Components/BlockerComponent.cpp
@@ -185,7 +185,7 @@ namespace Vegetation
 
     bool BlockerComponent::ClaimPosition(EntityIdStack& processedIds, const ClaimPoint& point, InstanceData& instanceData)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
 #if VEG_BLOCKER_ENABLE_CACHING
         {
@@ -245,7 +245,7 @@ namespace Vegetation
 
     void BlockerComponent::ClaimPositions(EntityIdStack& stackIds, ClaimContext& context)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         //adding entity id to the stack of entity ids affecting vegetation
         EntityIdStack emptyIds;
@@ -285,7 +285,7 @@ namespace Vegetation
 
     AZ::Aabb BlockerComponent::GetEncompassingAabb() const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZ::Aabb bounds = AZ::Aabb::CreateNull();
         LmbrCentral::ShapeComponentRequestsBus::EventResult(bounds, GetEntityId(), &LmbrCentral::ShapeComponentRequestsBus::Events::GetEncompassingAabb);
diff --git a/Gems/Vegetation/Code/Source/Components/DescriptorListCombinerComponent.cpp b/Gems/Vegetation/Code/Source/Components/DescriptorListCombinerComponent.cpp
index bcb42fb2e3..abdec31b98 100644
--- a/Gems/Vegetation/Code/Source/Components/DescriptorListCombinerComponent.cpp
+++ b/Gems/Vegetation/Code/Source/Components/DescriptorListCombinerComponent.cpp
@@ -187,7 +187,7 @@ namespace Vegetation
 
     void DescriptorListCombinerComponent::GetDescriptors(DescriptorPtrVec& descriptors) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         for (const auto& entityId : m_configuration.m_descriptorProviders)
         {
@@ -200,7 +200,7 @@ namespace Vegetation
 
     void DescriptorListCombinerComponent::GetInclusionSurfaceTags(SurfaceData::SurfaceTagVector& tags, bool& includeAll) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         for (const auto& entityId : m_configuration.m_descriptorProviders)
         {
@@ -213,7 +213,7 @@ namespace Vegetation
 
     void DescriptorListCombinerComponent::GetExclusionSurfaceTags(SurfaceData::SurfaceTagVector& tags) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         for (const auto& entityId : m_configuration.m_descriptorProviders)
         {
diff --git a/Gems/Vegetation/Code/Source/Components/DescriptorWeightSelectorComponent.cpp b/Gems/Vegetation/Code/Source/Components/DescriptorWeightSelectorComponent.cpp
index 5e4781302d..093de396dd 100644
--- a/Gems/Vegetation/Code/Source/Components/DescriptorWeightSelectorComponent.cpp
+++ b/Gems/Vegetation/Code/Source/Components/DescriptorWeightSelectorComponent.cpp
@@ -144,7 +144,7 @@ namespace Vegetation
 
     void DescriptorWeightSelectorComponent::SelectDescriptors(const DescriptorSelectorParams& params, DescriptorPtrVec& descriptors) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         switch (m_configuration.m_sortBehavior)
         {
diff --git a/Gems/Vegetation/Code/Source/Components/DistanceBetweenFilterComponent.cpp b/Gems/Vegetation/Code/Source/Components/DistanceBetweenFilterComponent.cpp
index 489862a797..e6d5701f64 100644
--- a/Gems/Vegetation/Code/Source/Components/DistanceBetweenFilterComponent.cpp
+++ b/Gems/Vegetation/Code/Source/Components/DistanceBetweenFilterComponent.cpp
@@ -187,7 +187,7 @@ namespace Vegetation
 
     bool DistanceBetweenFilterComponent::Evaluate(const InstanceData& instanceData) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         bool intersects = false;
 
diff --git a/Gems/Vegetation/Code/Source/Components/DistributionFilterComponent.cpp b/Gems/Vegetation/Code/Source/Components/DistributionFilterComponent.cpp
index 18a83347d4..2505b243ad 100644
--- a/Gems/Vegetation/Code/Source/Components/DistributionFilterComponent.cpp
+++ b/Gems/Vegetation/Code/Source/Components/DistributionFilterComponent.cpp
@@ -188,7 +188,7 @@ namespace Vegetation
 
     bool DistributionFilterComponent::Evaluate(const InstanceData& instanceData) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         const GradientSignal::GradientSampleParams sampleParams(instanceData.m_position);
         const float noise = m_configuration.m_gradientSampler.GetValue(sampleParams);
diff --git a/Gems/Vegetation/Code/Source/Components/MeshBlockerComponent.cpp b/Gems/Vegetation/Code/Source/Components/MeshBlockerComponent.cpp
index 58f23bff72..52461e691c 100644
--- a/Gems/Vegetation/Code/Source/Components/MeshBlockerComponent.cpp
+++ b/Gems/Vegetation/Code/Source/Components/MeshBlockerComponent.cpp
@@ -197,7 +197,7 @@ namespace Vegetation
 
     bool MeshBlockerComponent::PrepareToClaim([[maybe_unused]] EntityIdStack& stackIds)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::lock_guard<decltype(m_cacheMutex)> cacheLock(m_cacheMutex);
 
@@ -217,7 +217,7 @@ namespace Vegetation
 
     bool MeshBlockerComponent::ClaimPosition(EntityIdStack& processedIds, const ClaimPoint& point, InstanceData& instanceData)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::lock_guard<decltype(m_cacheMutex)> cacheLock(m_cacheMutex);
 
@@ -283,7 +283,7 @@ namespace Vegetation
 
     void MeshBlockerComponent::ClaimPositions(EntityIdStack& stackIds, ClaimContext& context)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         //adding entity id to the stack of entity ids affecting vegetation
         EntityIdStack emptyIds;
@@ -371,7 +371,7 @@ namespace Vegetation
 
     void MeshBlockerComponent::UpdateMeshData()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::lock_guard<decltype(m_cacheMutex)> cacheLock(m_cacheMutex);
 
diff --git a/Gems/Vegetation/Code/Source/Components/PositionModifierComponent.cpp b/Gems/Vegetation/Code/Source/Components/PositionModifierComponent.cpp
index 4d3b4f9867..17457786f2 100644
--- a/Gems/Vegetation/Code/Source/Components/PositionModifierComponent.cpp
+++ b/Gems/Vegetation/Code/Source/Components/PositionModifierComponent.cpp
@@ -281,7 +281,7 @@ namespace Vegetation
 
     void PositionModifierComponent::Execute(InstanceData& instanceData) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         const GradientSignal::GradientSampleParams sampleParams(instanceData.m_position);
         float factorX = m_configuration.m_gradientSamplerX.GetValue(sampleParams);
diff --git a/Gems/Vegetation/Code/Source/Components/RotationModifierComponent.cpp b/Gems/Vegetation/Code/Source/Components/RotationModifierComponent.cpp
index df52222edb..1c13c08c2f 100644
--- a/Gems/Vegetation/Code/Source/Components/RotationModifierComponent.cpp
+++ b/Gems/Vegetation/Code/Source/Components/RotationModifierComponent.cpp
@@ -239,7 +239,7 @@ namespace Vegetation
 
     void RotationModifierComponent::Execute(InstanceData& instanceData) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         const GradientSignal::GradientSampleParams sampleParams(instanceData.m_position);
         float factorX = m_configuration.m_gradientSamplerX.GetValue(sampleParams);
diff --git a/Gems/Vegetation/Code/Source/Components/ScaleModifierComponent.cpp b/Gems/Vegetation/Code/Source/Components/ScaleModifierComponent.cpp
index 74d11d6f6c..8c8099599d 100644
--- a/Gems/Vegetation/Code/Source/Components/ScaleModifierComponent.cpp
+++ b/Gems/Vegetation/Code/Source/Components/ScaleModifierComponent.cpp
@@ -162,7 +162,7 @@ namespace Vegetation
 
     void ScaleModifierComponent::Execute(InstanceData& instanceData) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         const GradientSignal::GradientSampleParams sampleParams(instanceData.m_position);
         float factor = m_configuration.m_gradientSampler.GetValue(sampleParams);
diff --git a/Gems/Vegetation/Code/Source/Components/ShapeIntersectionFilterComponent.cpp b/Gems/Vegetation/Code/Source/Components/ShapeIntersectionFilterComponent.cpp
index 27dabfd76e..968d711e04 100644
--- a/Gems/Vegetation/Code/Source/Components/ShapeIntersectionFilterComponent.cpp
+++ b/Gems/Vegetation/Code/Source/Components/ShapeIntersectionFilterComponent.cpp
@@ -147,7 +147,7 @@ namespace Vegetation
 
     bool ShapeIntersectionFilterComponent::Evaluate(const InstanceData& instanceData) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         bool inside = false;
         LmbrCentral::ShapeComponentRequestsBus::EventResult(inside, m_configuration.m_shapeEntityId, &LmbrCentral::ShapeComponentRequestsBus::Events::IsPointInside, instanceData.m_position);
diff --git a/Gems/Vegetation/Code/Source/Components/SlopeAlignmentModifierComponent.cpp b/Gems/Vegetation/Code/Source/Components/SlopeAlignmentModifierComponent.cpp
index 75a468b751..5e8e784bc6 100644
--- a/Gems/Vegetation/Code/Source/Components/SlopeAlignmentModifierComponent.cpp
+++ b/Gems/Vegetation/Code/Source/Components/SlopeAlignmentModifierComponent.cpp
@@ -159,7 +159,7 @@ namespace Vegetation
 
     void SlopeAlignmentModifierComponent::Execute(InstanceData& instanceData) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         const bool useOverrides = m_configuration.m_allowOverrides && instanceData.m_descriptorPtr && instanceData.m_descriptorPtr->m_surfaceAlignmentOverrideEnabled;
         const float min = useOverrides ? instanceData.m_descriptorPtr->m_surfaceAlignmentMin : m_configuration.m_rangeMin;
diff --git a/Gems/Vegetation/Code/Source/Components/SpawnerComponent.cpp b/Gems/Vegetation/Code/Source/Components/SpawnerComponent.cpp
index b373edf051..404e425489 100644
--- a/Gems/Vegetation/Code/Source/Components/SpawnerComponent.cpp
+++ b/Gems/Vegetation/Code/Source/Components/SpawnerComponent.cpp
@@ -206,7 +206,7 @@ namespace Vegetation
 
     bool SpawnerComponent::PrepareToClaim(EntityIdStack& stackIds)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         //adding entity id to the stack of entity ids affecting vegetation
         EntityIdStack emptyIds;
@@ -259,7 +259,7 @@ namespace Vegetation
 
     bool SpawnerComponent::CreateInstance([[maybe_unused]] const ClaimPoint &point, InstanceData& instanceData)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         instanceData.m_instanceId = InvalidInstanceId;
         if (instanceData.m_descriptorPtr && instanceData.m_descriptorPtr->IsSpawnable())
@@ -279,7 +279,7 @@ namespace Vegetation
 
     bool SpawnerComponent::EvaluateFilters(EntityIdStack& processedIds, InstanceData& instanceData, const FilterStage intendedStage) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         bool accepted = true;
         for (const auto& id : processedIds)
@@ -302,7 +302,7 @@ namespace Vegetation
 
     bool SpawnerComponent::ProcessInstance(EntityIdStack& processedIds, const ClaimPoint& point, InstanceData& instanceData, DescriptorPtr descriptorPtr)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         if (!descriptorPtr)
         {
@@ -353,7 +353,7 @@ namespace Vegetation
 
     bool SpawnerComponent::ClaimPosition(EntityIdStack& processedIds, const ClaimPoint& point, InstanceData& instanceData)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
 #if VEG_SPAWNER_ENABLE_CACHING
         {
@@ -413,7 +413,7 @@ namespace Vegetation
 
     void SpawnerComponent::ClaimPositions(EntityIdStack& stackIds, ClaimContext& context)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         //reject entire spawner if there are inclusion tags to consider that don't exist in the context
         if (SurfaceData::HasValidTags(context.m_masks) &&
@@ -497,7 +497,7 @@ namespace Vegetation
 
     void SpawnerComponent::UnclaimPosition(const ClaimHandle handle)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         InstanceId instanceId = InvalidInstanceId;
         {
@@ -518,7 +518,7 @@ namespace Vegetation
 
     AZ::Aabb SpawnerComponent::GetEncompassingAabb() const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZ::Aabb bounds = AZ::Aabb::CreateNull();
         LmbrCentral::ShapeComponentRequestsBus::EventResult(bounds, GetEntityId(), &LmbrCentral::ShapeComponentRequestsBus::Events::GetEncompassingAabb);
@@ -533,7 +533,7 @@ namespace Vegetation
 
     void SpawnerComponent::OnCompositionChanged()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
         AreaComponentBase::OnCompositionChanged();
 
 #if VEG_SPAWNER_ENABLE_CACHING
@@ -546,7 +546,7 @@ namespace Vegetation
 
     void SpawnerComponent::DestroyAllInstances()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         ClaimInstanceMapping claimInstanceMapping;
         {
diff --git a/Gems/Vegetation/Code/Source/Components/SurfaceAltitudeFilterComponent.cpp b/Gems/Vegetation/Code/Source/Components/SurfaceAltitudeFilterComponent.cpp
index e2a1404bf1..1f1dfd7a54 100644
--- a/Gems/Vegetation/Code/Source/Components/SurfaceAltitudeFilterComponent.cpp
+++ b/Gems/Vegetation/Code/Source/Components/SurfaceAltitudeFilterComponent.cpp
@@ -175,7 +175,7 @@ namespace Vegetation
 
     bool SurfaceAltitudeFilterComponent::Evaluate(const InstanceData& instanceData) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         const bool useOverrides = m_configuration.m_allowOverrides && instanceData.m_descriptorPtr && instanceData.m_descriptorPtr->m_altitudeFilterOverrideEnabled;
         const float min = useOverrides ? instanceData.m_descriptorPtr->m_altitudeFilterMin : m_configuration.m_altitudeMin;
diff --git a/Gems/Vegetation/Code/Source/Components/SurfaceMaskDepthFilterComponent.cpp b/Gems/Vegetation/Code/Source/Components/SurfaceMaskDepthFilterComponent.cpp
index f4bd07e816..b4e65beb3f 100644
--- a/Gems/Vegetation/Code/Source/Components/SurfaceMaskDepthFilterComponent.cpp
+++ b/Gems/Vegetation/Code/Source/Components/SurfaceMaskDepthFilterComponent.cpp
@@ -203,7 +203,7 @@ namespace Vegetation
 
     bool SurfaceMaskDepthFilterComponent::Evaluate(const InstanceData& instanceData) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         const bool useOverrides = m_configuration.m_allowOverrides && instanceData.m_descriptorPtr && !instanceData.m_descriptorPtr->m_surfaceTagDistance.m_tags.empty();
         const SurfaceData::SurfaceTagVector& surfaceTagsToCompare = useOverrides ? instanceData.m_descriptorPtr->m_surfaceTagDistance.m_tags : m_configuration.m_depthComparisonTags;
diff --git a/Gems/Vegetation/Code/Source/Components/SurfaceMaskFilterComponent.cpp b/Gems/Vegetation/Code/Source/Components/SurfaceMaskFilterComponent.cpp
index 8dd9821cb1..9be6764460 100644
--- a/Gems/Vegetation/Code/Source/Components/SurfaceMaskFilterComponent.cpp
+++ b/Gems/Vegetation/Code/Source/Components/SurfaceMaskFilterComponent.cpp
@@ -268,7 +268,7 @@ namespace Vegetation
 
     bool SurfaceMaskFilterComponent::Evaluate(const InstanceData& instanceData) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         //determine if tags provided by the component should be considered
         bool useCompTags = !m_configuration.m_allowOverrides || (instanceData.m_descriptorPtr && instanceData.m_descriptorPtr->m_surfaceFilterOverrideMode != OverrideMode::Replace);
diff --git a/Gems/Vegetation/Code/Source/Components/SurfaceSlopeFilterComponent.cpp b/Gems/Vegetation/Code/Source/Components/SurfaceSlopeFilterComponent.cpp
index b99c2b7c81..fb0673bdf2 100644
--- a/Gems/Vegetation/Code/Source/Components/SurfaceSlopeFilterComponent.cpp
+++ b/Gems/Vegetation/Code/Source/Components/SurfaceSlopeFilterComponent.cpp
@@ -162,7 +162,7 @@ namespace Vegetation
 
     bool SurfaceSlopeFilterComponent::Evaluate(const InstanceData& instanceData) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         const bool useOverrides = m_configuration.m_allowOverrides && instanceData.m_descriptorPtr && instanceData.m_descriptorPtr->m_slopeFilterOverrideEnabled;
         const float min = useOverrides ? instanceData.m_descriptorPtr->m_slopeFilterMin : m_configuration.m_slopeMin;
diff --git a/Gems/Vegetation/Code/Source/InstanceSystemComponent.cpp b/Gems/Vegetation/Code/Source/InstanceSystemComponent.cpp
index 74fb2696ea..d4185fde6c 100644
--- a/Gems/Vegetation/Code/Source/InstanceSystemComponent.cpp
+++ b/Gems/Vegetation/Code/Source/InstanceSystemComponent.cpp
@@ -169,7 +169,7 @@ namespace Vegetation
 
     DescriptorPtr InstanceSystemComponent::RegisterUniqueDescriptor(const Descriptor& descriptor)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::lock_guard<decltype(m_uniqueDescriptorsMutex)> lock(m_uniqueDescriptorsMutex);
 
@@ -217,7 +217,7 @@ namespace Vegetation
 
     void InstanceSystemComponent::ReleaseUniqueDescriptor(DescriptorPtr descriptorPtr)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::lock_guard<decltype(m_uniqueDescriptorsMutex)> lock(m_uniqueDescriptorsMutex);
 
@@ -267,7 +267,7 @@ namespace Vegetation
 
     void InstanceSystemComponent::CreateInstance(InstanceData& instanceData)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         if (!IsDescriptorValid(instanceData.m_descriptorPtr))
         {
@@ -299,7 +299,7 @@ namespace Vegetation
 
     void InstanceSystemComponent::DestroyInstance(InstanceId instanceId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         if (instanceId == InvalidInstanceId)
         {
@@ -439,7 +439,7 @@ namespace Vegetation
 
     bool InstanceSystemComponent::IsInstanceSkippable(const InstanceData& instanceData) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         //if the instance was queued for deletion before its creation task executed then skip it
         AZStd::lock_guard<decltype(m_instanceDeletionSetMutex)> instanceDeletionSet(m_instanceDeletionSetMutex);
@@ -448,7 +448,7 @@ namespace Vegetation
 
     void InstanceSystemComponent::CreateInstanceNode(const InstanceData& instanceData)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         if (IsInstanceSkippable(instanceData))
         {
@@ -489,7 +489,7 @@ namespace Vegetation
 
     void InstanceSystemComponent::ReleaseInstanceNode(InstanceId instanceId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         DescriptorPtr descriptor = nullptr;
         InstancePtr opaqueInstanceData = nullptr;
@@ -521,7 +521,7 @@ namespace Vegetation
 
     void InstanceSystemComponent::AddTask(const Task& task)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::lock_guard<decltype(m_mainThreadTaskMutex)> mainThreadTaskLock(m_mainThreadTaskMutex);
         if (m_mainThreadTaskQueue.empty() || m_mainThreadTaskQueue.back().size() >= m_configuration.m_maxInstanceTaskBatchSize)
@@ -534,7 +534,7 @@ namespace Vegetation
 
     void InstanceSystemComponent::ClearTasks()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::lock_guard<decltype(m_mainThreadTaskInProgressMutex)> mainThreadTaskInProgressLock(m_mainThreadTaskInProgressMutex);
         AZStd::lock_guard<decltype(m_mainThreadTaskMutex)> mainThreadTaskLock(m_mainThreadTaskMutex);
@@ -546,7 +546,7 @@ namespace Vegetation
 
     bool InstanceSystemComponent::GetTasks(TaskList& removedTasks)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::lock_guard<decltype(m_mainThreadTaskMutex)> mainThreadTaskLock(m_mainThreadTaskMutex);
         if (!m_mainThreadTaskQueue.empty())
@@ -559,7 +559,7 @@ namespace Vegetation
 
     void InstanceSystemComponent::ExecuteTasks()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         AZStd::lock_guard<decltype(m_mainThreadTaskInProgressMutex)> scopedLock(m_mainThreadTaskInProgressMutex);
 
@@ -588,7 +588,7 @@ namespace Vegetation
 
     void InstanceSystemComponent::ProcessMainThreadTasks()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+        AZ_PROFILE_FUNCTION(Entity);
 
         ExecuteTasks();
     }
diff --git a/Gems/WhiteBox/Code/Source/Core/WhiteBoxToolApi.cpp b/Gems/WhiteBox/Code/Source/Core/WhiteBoxToolApi.cpp
index 3bcd2dbd94..5ed409cd0d 100644
--- a/Gems/WhiteBox/Code/Source/Core/WhiteBoxToolApi.cpp
+++ b/Gems/WhiteBox/Code/Source/Core/WhiteBoxToolApi.cpp
@@ -253,7 +253,7 @@ namespace OpenMesh::IO
         // return binary size of the value
         static size_t size_of(const value_type& _v)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             if (_v.empty())
             {
@@ -274,7 +274,7 @@ namespace OpenMesh::IO
 
         static size_t store(std::ostream& _os, const value_type& _v, bool _swap = false)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             size_t bytes = 0;
             const auto count = static_cast<uint32_t>(_v.size());
@@ -291,7 +291,7 @@ namespace OpenMesh::IO
 
         static size_t restore(std::istream& _is, value_type& _v, bool _swap = false)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             size_t bytes = 0;
             uint32_t count = 0;
@@ -325,7 +325,7 @@ namespace OpenMesh::IO
         // return binary size of the value
         static size_t size_of(const value_type& _v)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             if (_v.empty())
             {
@@ -347,7 +347,7 @@ namespace OpenMesh::IO
 
         static size_t store(std::ostream& _os, const value_type& _v, bool _swap = false)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             size_t bytes = 0;
             const auto count = static_cast<uint32_t>(_v.size());
@@ -365,7 +365,7 @@ namespace OpenMesh::IO
 
         static size_t restore(std::istream& _is, value_type& _v, bool _swap = false)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             size_t bytes = 0;
             uint32_t count = 0;
@@ -483,7 +483,7 @@ namespace WhiteBox
 
     FaceHandlesInternal InternalFaceHandlesFromPolygon(const Api::PolygonHandle& polygonHandle)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         FaceHandlesInternal faceHandlesInternal;
         faceHandlesInternal.reserve(polygonHandle.m_faceHandles.size());
@@ -586,7 +586,7 @@ namespace WhiteBox
 
         VertexHandles MeshVertexHandles(const WhiteBoxMesh& whiteBox)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             VertexHandles vertexHandles;
             vertexHandles.reserve(whiteBox.mesh.n_vertices());
@@ -600,7 +600,7 @@ namespace WhiteBox
 
         FaceHandles MeshFaceHandles(const WhiteBoxMesh& whiteBox)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             FaceHandles faceHandles;
             faceHandles.reserve(whiteBox.mesh.n_faces());
@@ -614,7 +614,7 @@ namespace WhiteBox
 
         PolygonHandles MeshPolygonHandles(const WhiteBoxMesh& whiteBox)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             PolygonPropertyHandle polygonPropsHandle;
             whiteBox.mesh.get_property_handle(polygonPropsHandle, PolygonProps);
@@ -637,7 +637,7 @@ namespace WhiteBox
 
         EdgeHandlesCollection PolygonBorderEdgeHandles(const WhiteBoxMesh& whiteBox, const PolygonHandle& polygonHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             const HalfedgeHandlesCollection halfedgeHandlesCollection =
                 PolygonBorderHalfedgeHandles(whiteBox, polygonHandle);
@@ -663,7 +663,7 @@ namespace WhiteBox
 
         EdgeHandles PolygonBorderEdgeHandlesFlattened(const WhiteBoxMesh& whiteBox, const PolygonHandle& polygonHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             const EdgeHandlesCollection borderEdgeHandlesCollection = PolygonBorderEdgeHandles(whiteBox, polygonHandle);
 
@@ -679,7 +679,7 @@ namespace WhiteBox
 
         EdgeHandles MeshPolygonEdgeHandles(const WhiteBoxMesh& whiteBox)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             auto polygonHandles = MeshPolygonHandles(whiteBox);
 
@@ -698,7 +698,7 @@ namespace WhiteBox
 
         EdgeHandles MeshEdgeHandles(const WhiteBoxMesh& whiteBox)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             EdgeHandles edgeHandles;
             edgeHandles.reserve(whiteBox.mesh.n_edges());
@@ -712,7 +712,7 @@ namespace WhiteBox
 
         EdgeTypes MeshUserEdgeHandles(const WhiteBoxMesh& whiteBox)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             EdgeHandles userEdgeHandles = MeshPolygonEdgeHandles(whiteBox);
             AZStd::sort(userEdgeHandles.begin(), userEdgeHandles.end());
@@ -732,7 +732,7 @@ namespace WhiteBox
 
         AZStd::vector<AZ::Vector3> MeshVertexPositions(const WhiteBoxMesh& whiteBox)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             return VertexPositions(whiteBox, MeshVertexHandles(whiteBox));
         }
@@ -794,7 +794,7 @@ namespace WhiteBox
 
         AZStd::vector<AZ::Vector3> FacesPositions(const WhiteBoxMesh& whiteBox, const FaceHandles& faceHandles)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             AZStd::vector<AZ::Vector3> triangles;
             triangles.reserve(faceHandles.size() * 3);
@@ -866,7 +866,7 @@ namespace WhiteBox
 
         HalfedgeHandles VertexHalfedgeHandles(const WhiteBoxMesh& whiteBox, const VertexHandle vertexHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             HalfedgeHandles outgoingHandles = VertexOutgoingHalfedgeHandles(whiteBox, vertexHandle);
             HalfedgeHandles incomingHandles = VertexIncomingHalfedgeHandles(whiteBox, vertexHandle);
@@ -881,7 +881,7 @@ namespace WhiteBox
 
         EdgeHandles VertexEdgeHandles(const WhiteBoxMesh& whiteBox, const VertexHandle vertexHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             const auto omVertexHandle = om_vh(vertexHandle);
 
@@ -898,7 +898,7 @@ namespace WhiteBox
             const WhiteBoxMesh& whiteBox, const FaceHandle faceHandle, FaceHandles& faceHandles,
             const AZ::Vector3& normal)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             const auto* const found_fh = AZStd::find(faceHandles.cbegin(), faceHandles.cend(), faceHandle);
 
@@ -917,7 +917,7 @@ namespace WhiteBox
 
         static FaceHandle OppositeFaceHandle(const WhiteBoxMesh& whiteBox, const HalfedgeHandle halfedgeHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             const HalfedgeHandle oppositeHalfedgeHandle = HalfedgeOppositeHalfedgeHandle(whiteBox, halfedgeHandle);
 
@@ -936,7 +936,7 @@ namespace WhiteBox
             const WhiteBoxMesh& whiteBox, const FaceHandle faceHandle, FaceHandles& faceHandles,
             const AZ::Vector3& normal)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             if (BuildFaceHandles(whiteBox, faceHandle, faceHandles, normal))
             {
@@ -957,7 +957,7 @@ namespace WhiteBox
 
         FaceHandles SideFaceHandles(const WhiteBoxMesh& whiteBox, const FaceHandle faceHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             FaceHandles faceHandles;
             SideFaceHandlesInternal(
@@ -969,7 +969,7 @@ namespace WhiteBox
         static HalfedgeHandlesCollection BorderHalfedgeHandles(
             const WhiteBoxMesh& whiteBox, const FaceHandles& faceHandles)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // build all possible halfedge handles
             HalfedgeHandles halfedgeHandles;
@@ -1069,7 +1069,7 @@ namespace WhiteBox
 
         HalfedgeHandlesCollection SideBorderHalfedgeHandles(const WhiteBoxMesh& whiteBox, const FaceHandle faceHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // find all face handles for a side
             return BorderHalfedgeHandles(whiteBox, SideFaceHandles(whiteBox, faceHandle));
@@ -1078,7 +1078,7 @@ namespace WhiteBox
         static VertexHandlesCollection BorderVertexHandles(
             const WhiteBoxMesh& whiteBox, const HalfedgeHandlesCollection& halfedgeHandlesCollection)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             VertexHandlesCollection orderedVertexHandlesCollection;
             orderedVertexHandlesCollection.reserve(halfedgeHandlesCollection.size());
@@ -1101,14 +1101,14 @@ namespace WhiteBox
 
         VertexHandlesCollection SideBorderVertexHandles(const WhiteBoxMesh& whiteBox, const FaceHandle faceHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             return BorderVertexHandles(whiteBox, SideBorderHalfedgeHandles(whiteBox, faceHandle));
         }
 
         static VertexHandles FacesVertexHandles(const WhiteBoxMesh& whiteBox, const FaceHandles& faceHandles)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             VertexHandles vertexHandles;
             for (const FaceHandle faceHandle : faceHandles)
@@ -1132,7 +1132,7 @@ namespace WhiteBox
 
         VertexHandles SideVertexHandles(const WhiteBoxMesh& whiteBox, const FaceHandle faceHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             return FacesVertexHandles(whiteBox, SideFaceHandles(whiteBox, faceHandle));
         }
@@ -1252,7 +1252,7 @@ namespace WhiteBox
         static bool EdgeIsUser(
             const WhiteBoxMesh& whiteBox, const HalfedgeHandle halfedgeHandle, const EdgeHandle edgeHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             const auto polygonEdgeHandles = PolygonBorderEdgeHandlesFlattened(
                 whiteBox, FacePolygonHandle(whiteBox, HalfedgeFaceHandle(whiteBox, halfedgeHandle)));
@@ -1276,7 +1276,7 @@ namespace WhiteBox
 
         EdgeHandles EdgeGrouping(const WhiteBoxMesh& whiteBox, const EdgeHandle edgeHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // a non-user ('mesh') edge is never part of a grouping so if one is passed
             // in ensure we return an empty group
@@ -1349,7 +1349,7 @@ namespace WhiteBox
 
         bool EdgeIsHidden(const WhiteBoxMesh& whiteBox, const EdgeHandle edgeHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             const EdgeHandles userEdgeHandles = MeshPolygonEdgeHandles(whiteBox);
             return AZStd::find(userEdgeHandles.cbegin(), userEdgeHandles.cend(), edgeHandle) == userEdgeHandles.cend();
@@ -1357,7 +1357,7 @@ namespace WhiteBox
 
         AZStd::vector<FaceHandle> EdgeFaceHandles(const WhiteBoxMesh& whiteBox, const EdgeHandle edgeHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             const auto openMeshEdgeHandle = om_eh(edgeHandle);
             const auto firstHalfedgeHandle = whiteBox.mesh.halfedge_handle(openMeshEdgeHandle, 0);
@@ -1405,7 +1405,7 @@ namespace WhiteBox
 
         HalfedgeHandles EdgeHalfedgeHandles(const WhiteBoxMesh& whiteBox, EdgeHandle edgeHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             const AZStd::array<HalfedgeHandle, 2> halfedgeHandles = {
                 EdgeHalfedgeHandle(whiteBox, edgeHandle, EdgeHalfedge::First),
@@ -1429,7 +1429,7 @@ namespace WhiteBox
             WHITEBOX_LOG(
                 "White Box", "TranslateEdge eh(%s) %s", ToString(edgeHandle).c_str(),
                 AZ::ToString(displacement).c_str());
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             const auto vertexHandles = EdgeVertexHandles(whiteBox, edgeHandle);
             for (const auto& vertexHandle : vertexHandles)
@@ -1450,7 +1450,7 @@ namespace WhiteBox
         static HalfedgeHandle FindBestFitHalfedge(
             WhiteBoxMesh& whiteBox, const EdgeHandle edgeHandle, const AZ::Vector3& displacement)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // get both halfedge handles for the edge (0 and 1 just correspond to each halfedge)
             const HalfedgeHandle firstHalfedgeHandle = EdgeHalfedgeHandle(whiteBox, edgeHandle, EdgeHalfedge::First);
@@ -1495,7 +1495,7 @@ namespace WhiteBox
         static Internal::EdgeAppendVertexHandles CalculateEdgeAppendVertexHandles(
             WhiteBoxMesh& whiteBox, const EdgeHandle edgeHandle, const AZ::Vector3& displacement)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // based on the displacement find which halfedge is a better fit (which direction did we move in)
             const HalfedgeHandle halfedgeHandle = FindBestFitHalfedge(whiteBox, edgeHandle, displacement);
@@ -1575,7 +1575,7 @@ namespace WhiteBox
         static Internal::EdgeAppendPolygonHandles AddNewPolygonsForEdgeAppend(
             WhiteBoxMesh& whiteBox, const Internal::EdgeAppendVertexHandles& edgeAppendVertexHandles)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             Internal::EdgeAppendPolygonHandles edgeAppendPolygonHandles;
 
@@ -1636,7 +1636,7 @@ namespace WhiteBox
         static EdgeHandle FindSelectedEdgeHandle(
             const WhiteBoxMesh& whiteBox, const PolygonHandle& nearPolygonHandle, const PolygonHandle& farPolygonHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // actually find the new edge we created
             const EdgeHandles nearEdgeHandles = PolygonBorderEdgeHandlesFlattened(whiteBox, nearPolygonHandle);
@@ -1670,7 +1670,7 @@ namespace WhiteBox
             WHITEBOX_LOG(
                 "White Box", "TranslateEdgeAppend eh(%s) %s", ToString(edgeHandle).c_str(),
                 AZ::ToString(displacement).c_str());
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // the new and existing handles required for an edge append
             const Internal::EdgeAppendVertexHandles edgeAppendVertexHandles =
@@ -1698,7 +1698,7 @@ namespace WhiteBox
 
         AZ::Vector3 PolygonNormal(const WhiteBoxMesh& whiteBox, const PolygonHandle& polygonHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             return AZStd::accumulate(
                        polygonHandle.m_faceHandles.cbegin(), polygonHandle.m_faceHandles.cend(),
@@ -1712,7 +1712,7 @@ namespace WhiteBox
 
         PolygonHandle FacePolygonHandle(const WhiteBoxMesh& whiteBox, const FaceHandle faceHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             PolygonPropertyHandle polygonPropsHandle;
             whiteBox.mesh.get_property_handle(polygonPropsHandle, PolygonProps);
@@ -1730,7 +1730,7 @@ namespace WhiteBox
 
         VertexHandles PolygonVertexHandles(const WhiteBoxMesh& whiteBox, const PolygonHandle& polygonHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             return FacesVertexHandles(whiteBox, polygonHandle.m_faceHandles);
         }
@@ -1738,7 +1738,7 @@ namespace WhiteBox
         VertexHandlesCollection PolygonBorderVertexHandles(
             const WhiteBoxMesh& whiteBox, const PolygonHandle& polygonHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             return BorderVertexHandles(whiteBox, PolygonBorderHalfedgeHandles(whiteBox, polygonHandle));
         }
@@ -1746,7 +1746,7 @@ namespace WhiteBox
         VertexHandles PolygonBorderVertexHandlesFlattened(
             const WhiteBoxMesh& whiteBox, const PolygonHandle& polygonHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             const VertexHandlesCollection borderVertexHandlesCollection =
                 BorderVertexHandles(whiteBox, PolygonBorderHalfedgeHandles(whiteBox, polygonHandle));
@@ -1764,7 +1764,7 @@ namespace WhiteBox
         HalfedgeHandles PolygonBorderHalfedgeHandlesFlattened(
             const WhiteBoxMesh& whiteBox, const PolygonHandle& polygonHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             const HalfedgeHandlesCollection borderHalfedgeHandlesCollection =
                 PolygonBorderHalfedgeHandles(whiteBox, polygonHandle);
@@ -1781,7 +1781,7 @@ namespace WhiteBox
 
         HalfedgeHandles PolygonHalfedgeHandles(const WhiteBoxMesh& whiteBox, const PolygonHandle& polygonHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             return AZStd::accumulate(
                 polygonHandle.m_faceHandles.cbegin(), polygonHandle.m_faceHandles.cend(), HalfedgeHandles{},
@@ -1802,7 +1802,7 @@ namespace WhiteBox
         AZStd::vector<AZ::Vector3> PolygonVertexPositions(
             const WhiteBoxMesh& whiteBox, const PolygonHandle& polygonHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             return VertexPositions(whiteBox, PolygonVertexHandles(whiteBox, polygonHandle));
         }
@@ -1810,7 +1810,7 @@ namespace WhiteBox
         VertexPositionsCollection PolygonBorderVertexPositions(
             const WhiteBoxMesh& whiteBox, const PolygonHandle& polygonHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             const auto polygonBorderVertexHandlesCollection = PolygonBorderVertexHandles(whiteBox, polygonHandle);
             VertexPositionsCollection polygonBorderVertexPositionsCollection;
@@ -1827,7 +1827,7 @@ namespace WhiteBox
         AZStd::vector<AZ::Vector3> PolygonFacesPositions(
             const WhiteBoxMesh& whiteBox, const PolygonHandle& polygonHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             return FacesPositions(whiteBox, polygonHandle.m_faceHandles);
         }
@@ -1854,7 +1854,7 @@ namespace WhiteBox
 
         EdgeHandles VertexUserEdgeHandles(const WhiteBoxMesh& whiteBox, const VertexHandle vertexHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             auto vertexEdgeHandles = VertexEdgeHandles(whiteBox, vertexHandle);
 
@@ -1874,7 +1874,7 @@ namespace WhiteBox
         static AZStd::vector<AZ::Vector3> VertexUserEdges(
             const WhiteBoxMesh& whiteBox, const VertexHandle vertexHandle, EdgeFn&& edgeFn)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             const auto vertexEdgeHandles = VertexUserEdgeHandles(whiteBox, vertexHandle);
 
@@ -1931,13 +1931,13 @@ namespace WhiteBox
 
         AZ::Vector3 FaceNormal(const WhiteBoxMesh& whiteBox, const FaceHandle faceHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
             return whiteBox.mesh.normal(om_fh(faceHandle));
         }
 
         AZ::Vector2 HalfedgeUV(const WhiteBoxMesh& whiteBox, const HalfedgeHandle halfedgeHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
             return whiteBox.mesh.texcoord2D(om_heh(halfedgeHandle));
         }
 
@@ -1964,7 +1964,7 @@ namespace WhiteBox
 
         Faces MeshFaces(const WhiteBoxMesh& whiteBox)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             Faces faces;
             faces.reserve(MeshFaceCount(whiteBox));
@@ -1989,7 +1989,7 @@ namespace WhiteBox
 
         void CalculatePlanarUVs(WhiteBoxMesh& whiteBox, const FaceHandles& faceHandles)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             auto& mesh = whiteBox.mesh;
             for (const auto faceHandle : faceHandles)
@@ -2012,7 +2012,7 @@ namespace WhiteBox
 
         void CalculatePlanarUVs(WhiteBoxMesh& whiteBox)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             CalculatePlanarUVs(whiteBox, MeshFaceHandles(whiteBox));
         }
@@ -2022,7 +2022,7 @@ namespace WhiteBox
             const HalfedgeHandle oppositeHalfedgeHandle, const HalfedgeHandles& borderHalfedgeHandles,
             const EdgeHandles& buildingEdgeHandles)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // the polygon handle to build
             PolygonHandle polygonHandle;
@@ -2119,7 +2119,7 @@ namespace WhiteBox
             WhiteBoxMesh& whiteBox, const EdgeHandle edgeHandle, EdgeHandles& restoringEdgeHandles)
         {
             WHITEBOX_LOG("White Box", "RestoreEdge eh(%s)", ToString(edgeHandle).c_str());
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // check we're not selecting an existing user edge
             if (!EdgeIsHidden(whiteBox, edgeHandle))
@@ -2231,7 +2231,7 @@ namespace WhiteBox
         PolygonHandle HideEdge(WhiteBoxMesh& whiteBox, const EdgeHandle edgeHandle)
         {
             WHITEBOX_LOG("White Box", "HideEdge eh(%s)", ToString(edgeHandle).c_str());
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             if (MeshHalfedgeCount(whiteBox) == 0)
             {
@@ -2296,7 +2296,7 @@ namespace WhiteBox
         VertexHandle SplitFace(WhiteBoxMesh& whiteBox, const FaceHandle faceHandle, const AZ::Vector3& position)
         {
             WHITEBOX_LOG("White Box", "SplitFace fh(%s)", ToString(faceHandle).c_str());
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             const auto omFaceHandle = om_fh(faceHandle);
             const auto omVertexHandle = whiteBox.mesh.split_copy(omFaceHandle, position);
@@ -2340,7 +2340,7 @@ namespace WhiteBox
         VertexHandle SplitEdge(WhiteBoxMesh& whiteBox, const EdgeHandle edgeHandle, const AZ::Vector3& position)
         {
             WHITEBOX_LOG("White Box", "SplitEdge eh(%s)", ToString(edgeHandle).c_str());
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             const HalfedgeHandle halfedgeHandle = EdgeHalfedgeHandle(whiteBox, edgeHandle, EdgeHalfedge::First);
             const VertexHandle tailVertexHandle = HalfedgeVertexHandleAtTail(whiteBox, halfedgeHandle);
@@ -2441,7 +2441,7 @@ namespace WhiteBox
 
         void Clear(WhiteBoxMesh& whiteBox)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             PolygonPropertyHandle polygonPropsHandle;
             whiteBox.mesh.get_property_handle(polygonPropsHandle, PolygonProps);
@@ -2462,7 +2462,7 @@ namespace WhiteBox
             WHITEBOX_LOG(
                 "White Box", "AddTriPolygon vh(%s), vh(%s), vh(%s)", ToString(vh0).c_str(), ToString(vh1).c_str(),
                 ToString(vh2).c_str());
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             return AddPolygon(whiteBox, AZStd::vector<FaceVertHandles>{{vh0, vh1, vh2}});
         }
@@ -2474,7 +2474,7 @@ namespace WhiteBox
             WHITEBOX_LOG(
                 "White Box", "AddQuadPolygon vh(%s), vh(%s), vh(%s), vh(%s)", ToString(vh0).c_str(),
                 ToString(vh1).c_str(), ToString(vh2).c_str(), ToString(vh3).c_str());
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             return AddPolygon(whiteBox, AZStd::vector<FaceVertHandles>{{vh0, vh1, vh2}, {vh0, vh2, vh3}});
         }
@@ -2482,7 +2482,7 @@ namespace WhiteBox
         PolygonHandle AddPolygon(WhiteBoxMesh& whiteBox, const FaceVertHandlesList& faceVertHandles)
         {
             WHITEBOX_LOG("White Box", "AddPolygon [%s]", ToString(faceVertHandles).c_str());
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             PolygonPropertyHandle polygonPropsHandle;
             whiteBox.mesh.get_property_handle(polygonPropsHandle, PolygonProps);
@@ -2510,7 +2510,7 @@ namespace WhiteBox
 
         PolygonHandles InitializeAsUnitCube(WhiteBoxMesh& whiteBox)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // generate vertices
             VertexHandle vertexHandles[8];
@@ -2550,7 +2550,7 @@ namespace WhiteBox
 
         PolygonHandle InitializeAsUnitQuad(WhiteBoxMesh& whiteBox)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // generate vertices
             VertexHandle vertexHandles[4];
@@ -2573,7 +2573,7 @@ namespace WhiteBox
 
         PolygonHandle InitializeAsUnitTriangle(WhiteBoxMesh& whiteBox)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // generate vertices
             VertexHandle vertexHandles[3];
@@ -2602,7 +2602,7 @@ namespace WhiteBox
             WHITEBOX_LOG(
                 "White Box", "SetVertexPosition vh(%s) %s", ToString(vertexHandle).c_str(),
                 AZ::ToString(position).c_str());
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             whiteBox.mesh.set_point(om_vh(vertexHandle), position);
         }
@@ -2613,7 +2613,7 @@ namespace WhiteBox
             WHITEBOX_LOG(
                 "White Box", "SetVertexPositionAndUpdateUVs vh(%s) %s", ToString(vertexHandle).c_str(),
                 AZ::ToString(position).c_str());
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             SetVertexPosition(whiteBox, vertexHandle, position);
             CalculatePlanarUVs(whiteBox);
@@ -2622,7 +2622,7 @@ namespace WhiteBox
         VertexHandle AddVertex(WhiteBoxMesh& whiteBox, const AZ::Vector3& vertex)
         {
             WHITEBOX_LOG("White Box", "AddVertex %s", AZ::ToString(vertex).c_str());
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             return wb_vh(whiteBox.mesh.add_vertex(vertex));
         }
@@ -2632,21 +2632,21 @@ namespace WhiteBox
             WHITEBOX_LOG(
                 "White Box", "AddFace vh(%s), vh(%s), vh(%s)", ToString(v0).c_str(), ToString(v1).c_str(),
                 ToString(v2).c_str());
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             return wb_fh(whiteBox.mesh.add_face(om_vh(v0), om_vh(v1), om_vh(v2)));
         }
 
         void CalculateNormals(WhiteBoxMesh& whiteBox)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             whiteBox.mesh.update_normals();
         }
 
         void ZeroUVs(WhiteBoxMesh& whiteBox)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             for (const Mesh::FaceHandle faceHandle : whiteBox.mesh.faces())
             {
@@ -2692,7 +2692,7 @@ namespace WhiteBox
 
         AZ::Vector3 VerticesMidpoint(const WhiteBoxMesh& whiteBox, const VertexHandles& vertexHandles)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             AzToolsFramework::MidpointCalculator midpointCalculator;
             for (const auto vertexHandle : vertexHandles)
@@ -2707,7 +2707,7 @@ namespace WhiteBox
             const WhiteBoxMesh& whiteBox, const Internal::VertexHandlePair vertexHandlePair,
             const PolygonHandle& selectedPolygonHandle, const PolygonHandle& adjacentPolygonHandle)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             const auto selectedPolygonEdgeHandles = PolygonBorderEdgeHandlesFlattened(whiteBox, selectedPolygonHandle);
             const auto adjacentPolygonEdgeHandles = PolygonBorderEdgeHandlesFlattened(whiteBox, adjacentPolygonHandle);
@@ -2744,7 +2744,7 @@ namespace WhiteBox
             const PolygonHandle& selectedPolygonHandle, const PolygonHandle& adjacentPolygonHandle,
             FaceVertHandlesCollection& vertsForLinkingAdjacentPolygons)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // if we found a valid halfedge
             if (const HalfedgeHandle foundHalfedgeHandle = FindHalfedgeInAdjacentPolygon(
@@ -2851,7 +2851,7 @@ namespace WhiteBox
             FaceVertHandlesCollection& vertsForExistingAdjacentPolygons,
             FaceVertHandlesCollection& vertsForLinkingAdjacentPolygons)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // adjacent faces
             for (size_t index = 0; index < borderVertexHandles.size(); ++index)
@@ -2912,7 +2912,7 @@ namespace WhiteBox
         // during garbage_collect
         void RemoveFaces(WhiteBoxMesh& whiteBox, const FaceHandles& faceHandles)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             whiteBox.mesh.request_face_status();
             whiteBox.mesh.request_edge_status();
@@ -3014,7 +3014,7 @@ namespace WhiteBox
         AZStd::vector<FaceVertHandles> BuildNewVertexFaceHandles(
             WhiteBoxMesh& whiteBox, const Internal::AppendedVerts& appendedVerts, const FaceHandles& existingFaces)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             AZStd::vector<FaceVertHandles> faces;
             faces.reserve(existingFaces.size());
@@ -3068,7 +3068,7 @@ namespace WhiteBox
             WhiteBoxMesh& whiteBox, const VertexHandles& existingVertexHandles, const PolygonHandle& polygonHandle,
             AppendVertFn&& appendFn)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             const AZ::Vector3 polygonNormal = PolygonNormal(whiteBox, polygonHandle);
             const auto polygonHalfedgeHandles = PolygonHalfedgeHandles(whiteBox, polygonHandle);
@@ -3146,7 +3146,7 @@ namespace WhiteBox
         static AppendedPolygonHandles Extrude(
             WhiteBoxMesh& whiteBox, const PolygonHandle& polygonHandle, AppendVertexFn&& appendFn)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // find border vertex handles for polygon
             const auto polygonBorderVertexHandlesCollection = PolygonBorderVertexHandles(whiteBox, polygonHandle);
@@ -3261,7 +3261,7 @@ namespace WhiteBox
             WhiteBoxMesh& whiteBox, const PolygonHandle& polygonHandle, const float distance)
         {
             WHITEBOX_LOG("White Box", "TranslatePolygonAppend ph(%s) %f", ToString(polygonHandle).c_str(), distance)
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             return TranslatePolygonAppendAdvanced(whiteBox, polygonHandle, distance).m_appendedPolygonHandle;
         }
@@ -3271,7 +3271,7 @@ namespace WhiteBox
         {
             WHITEBOX_LOG(
                 "White Box", "TranslatePolygonAppendAdvanced ph(%s) %f", ToString(polygonHandle).c_str(), distance)
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // check mesh has faces
             if (whiteBox.mesh.n_faces() == 0)
@@ -3288,7 +3288,7 @@ namespace WhiteBox
         void TranslatePolygon(WhiteBoxMesh& whiteBox, const PolygonHandle& polygonHandle, const float distance)
         {
             WHITEBOX_LOG("White Box", "TranslatePolygon ph(%s) %d", ToString(polygonHandle).c_str(), distance)
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             const auto vertexHandles = PolygonVertexHandles(whiteBox, polygonHandle);
             const auto vertexPositions = VertexPositions(whiteBox, vertexHandles);
@@ -3306,7 +3306,7 @@ namespace WhiteBox
             WhiteBoxMesh& whiteBox, const PolygonHandle& polygonHandle, const float scale)
         {
             WHITEBOX_LOG("White Box", "ScalePolygonAppendRelative ph(%s) %f", ToString(polygonHandle).c_str(), scale);
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             // check mesh has faces
             if (whiteBox.mesh.n_faces() == 0)
@@ -3329,7 +3329,7 @@ namespace WhiteBox
 
         static AZ::Transform BuildSpace(const AZ::Vector3& normal, const AZ::Vector3& pivot)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             AZ::Vector3 axis1;
             AZ::Vector3 axis2;
@@ -3359,7 +3359,7 @@ namespace WhiteBox
             WHITEBOX_LOG(
                 "White Box", "ScalePolygonRelative ph(%s) pivot %s scale: %f", ToString(polygonHandle).c_str(),
                 AZ::ToString(pivot).c_str(), scaleDelta);
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             const AZ::Transform polygonSpace = PolygonSpace(whiteBox, polygonHandle, pivot);
             for (const auto vertexHandle : PolygonVertexHandles(whiteBox, polygonHandle))
@@ -3375,7 +3375,7 @@ namespace WhiteBox
 
         bool WriteMesh(const WhiteBoxMesh& whiteBox, WhiteBoxMeshStream& output)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             AZStd::lock_guard lg(g_omSerializationLock);
 
@@ -3399,7 +3399,7 @@ namespace WhiteBox
 
         ReadResult ReadMesh(WhiteBoxMesh& whiteBox, const WhiteBoxMeshStream& input)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             if (input.empty())
             {
@@ -3434,7 +3434,7 @@ namespace WhiteBox
 
         WhiteBoxMeshPtr CloneMesh(const WhiteBoxMesh& whiteBox)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+            AZ_PROFILE_FUNCTION(AzToolsFramework);
 
             WhiteBoxMeshStream clonedData;
             if (!WriteMesh(whiteBox, clonedData))
diff --git a/Gems/WhiteBox/Code/Source/EditorWhiteBoxComponent.cpp b/Gems/WhiteBox/Code/Source/EditorWhiteBoxComponent.cpp
index ad59da63d5..61796bde58 100644
--- a/Gems/WhiteBox/Code/Source/EditorWhiteBoxComponent.cpp
+++ b/Gems/WhiteBox/Code/Source/EditorWhiteBoxComponent.cpp
@@ -61,7 +61,7 @@ namespace WhiteBox
     // to be used to generate concrete render mesh
     static WhiteBoxRenderData CreateWhiteBoxRenderData(const WhiteBoxMesh& whiteBox, const WhiteBoxMaterial& material)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         WhiteBoxRenderData renderData;
         WhiteBoxFaces& faceData = renderData.m_faces;
@@ -407,7 +407,7 @@ namespace WhiteBox
 
     void EditorWhiteBoxComponent::RebuildRenderMesh()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // reset caches when the mesh changes
         m_worldAabb.reset();
@@ -474,7 +474,7 @@ namespace WhiteBox
     void EditorWhiteBoxComponent::OnTransformChanged(
         [[maybe_unused]] const AZ::Transform& local, const AZ::Transform& world)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         m_worldAabb.reset();
         m_localAabb.reset();
@@ -490,7 +490,7 @@ namespace WhiteBox
 
     void EditorWhiteBoxComponent::RebuildPhysicsMesh()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         EditorWhiteBoxColliderRequestBus::Event(
             GetEntityId(), &EditorWhiteBoxColliderRequests::CreatePhysics, *GetWhiteBoxMesh());
@@ -673,7 +673,7 @@ namespace WhiteBox
 
     AZ::Aabb EditorWhiteBoxComponent::GetWorldBounds()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (!m_worldAabb.has_value())
         {
@@ -686,7 +686,7 @@ namespace WhiteBox
 
     AZ::Aabb EditorWhiteBoxComponent::GetLocalBounds()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (!m_localAabb.has_value())
         {
@@ -708,7 +708,7 @@ namespace WhiteBox
         [[maybe_unused]] const AzFramework::ViewportInfo& viewportInfo, const AZ::Vector3& src, const AZ::Vector3& dir,
         float& distance)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (!m_faces.has_value())
         {
@@ -905,7 +905,7 @@ namespace WhiteBox
     void EditorWhiteBoxComponent::DisplayEntityViewport(
         [[maybe_unused]] const AzFramework::ViewportInfo& viewportInfo, AzFramework::DebugDisplayRequests& debugDisplay)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (DebugDrawingEnabled())
         {
diff --git a/Gems/WhiteBox/Code/Source/EditorWhiteBoxComponentMode.cpp b/Gems/WhiteBox/Code/Source/EditorWhiteBoxComponentMode.cpp
index 3d04c87e6a..cd9e8090cd 100644
--- a/Gems/WhiteBox/Code/Source/EditorWhiteBoxComponentMode.cpp
+++ b/Gems/WhiteBox/Code/Source/EditorWhiteBoxComponentMode.cpp
@@ -209,7 +209,7 @@ namespace WhiteBox
     bool EditorWhiteBoxComponentMode::HandleMouseInteraction(
         const AzToolsFramework::ViewportInteraction::MouseInteractionEvent& mouseInteraction)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         WhiteBoxMesh* whiteBox = nullptr;
         EditorWhiteBoxComponentRequestBus::EventResult(
@@ -301,7 +301,7 @@ namespace WhiteBox
     void EditorWhiteBoxComponentMode::DisplayEntityViewport(
         [[maybe_unused]] const AzFramework::ViewportInfo& viewportInfo, AzFramework::DebugDisplayRequests& debugDisplay)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const auto modifiers = m_keyboardMofifierQueryFn();
 
@@ -374,7 +374,7 @@ namespace WhiteBox
 
     void EditorWhiteBoxComponentMode::RecalculateWhiteBoxIntersectionData(const EdgeSelectionType edgeSelectionMode)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         WhiteBoxMesh* whiteBox = nullptr;
         EditorWhiteBoxComponentRequestBus::EventResult(
diff --git a/Gems/WhiteBox/Code/Source/EditorWhiteBoxComponentModeTypes.cpp b/Gems/WhiteBox/Code/Source/EditorWhiteBoxComponentModeTypes.cpp
index 239c8a3066..cbde5f4f4b 100644
--- a/Gems/WhiteBox/Code/Source/EditorWhiteBoxComponentModeTypes.cpp
+++ b/Gems/WhiteBox/Code/Source/EditorWhiteBoxComponentModeTypes.cpp
@@ -8,6 +8,7 @@
 
 #include "EditorWhiteBoxComponentModeTypes.h"
 
+#include <AzCore/Debug/Profiler.h>
 #include <AzFramework/Entity/EntityDebugDisplayBus.h>
 
 namespace WhiteBox
@@ -16,7 +17,7 @@ namespace WhiteBox
         AzFramework::DebugDisplayRequests& debugDisplay, const AZ::Color& color,
         const AZStd::vector<EdgeBoundWithHandle>& edgeBoundsWithHandle, const Api::EdgeHandles& excludedEdgeHandles)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         debugDisplay.SetColor(color);
         for (const EdgeBoundWithHandle& edge : edgeBoundsWithHandle)
diff --git a/Gems/WhiteBox/Code/Source/SubComponentModes/EditorWhiteBoxDefaultMode.cpp b/Gems/WhiteBox/Code/Source/SubComponentModes/EditorWhiteBoxDefaultMode.cpp
index 136db8802c..3d6d9a4c0a 100644
--- a/Gems/WhiteBox/Code/Source/SubComponentModes/EditorWhiteBoxDefaultMode.cpp
+++ b/Gems/WhiteBox/Code/Source/SubComponentModes/EditorWhiteBoxDefaultMode.cpp
@@ -212,7 +212,7 @@ namespace WhiteBox
         AzFramework::DebugDisplayRequests& debugDisplay, const AZ::Transform& worldFromLocal,
         const AzFramework::CameraState& cameraState, const IntersectionAndRenderData& renderData)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         const float vertexIndicatorLength = cl_whiteBoxVertexIndicatorLength;
         const float vertexIndicatorWidth = cl_whiteBoxVertexIndicatorWidth;
@@ -252,7 +252,7 @@ namespace WhiteBox
         const IntersectionAndRenderData& renderData, [[maybe_unused]] const AzFramework::ViewportInfo& viewportInfo,
         AzFramework::DebugDisplayRequests& debugDisplay)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         TryDestroyModifier(m_polygonTranslationModifier);
         TryDestroyModifier(m_edgeTranslationModifier);
@@ -276,7 +276,7 @@ namespace WhiteBox
 
     Api::EdgeHandles DefaultMode::FindInteractiveEdgeHandles(const WhiteBoxMesh& whiteBox)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         // get all edge handles for hovered polygon
         const Api::EdgeHandles polygonHoveredEdgeHandles = m_polygonTranslationModifier
@@ -322,7 +322,7 @@ namespace WhiteBox
         const WhiteBoxMesh& whiteBox, const PolygonScaleModifier* polygonScaleModifier,
         const EdgeScaleModifier* edgeScaleModifier, const Api::VertexHandle vertexHandle)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         if (Api::VertexIsHidden(whiteBox, vertexHandle))
         {
@@ -371,7 +371,7 @@ namespace WhiteBox
         const AZStd::optional<PolygonIntersection>& polygonIntersection,
         const AZStd::optional<VertexIntersection>& vertexIntersection)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
+        AZ_PROFILE_FUNCTION(AzToolsFramework);
 
         WhiteBoxMesh* whiteBox = nullptr;
         EditorWhiteBoxComponentRequestBus::EventResult(

From a5f072f7a9eaba93ca3830fa580480689ffcd2cb Mon Sep 17 00:00:00 2001
From: Jeremy Ong <jcong@amazon.com>
Date: Tue, 17 Aug 2021 14:51:29 -0600
Subject: [PATCH 28/37] Remove statistics profiler

Signed-off-by: Jeremy Ong <jcong@amazon.com>
---
 Code/Framework/AzCore/AzCore/Debug/Profiler.h |  18 +-
 .../Statistics/RunningStatisticsManager.cpp   | 106 ---
 .../AzCore/Statistics/StatisticalProfiler.h   | 255 ------
 .../Statistics/StatisticalProfilerProxy.h     | 170 ----
 ...tatisticalProfilerProxySystemComponent.cpp |  66 --
 .../StatisticalProfilerProxySystemComponent.h |  67 --
 .../AzCore/Statistics/StatisticsManager.h     | 200 -----
 .../Statistics/TimeDataStatisticsManager.cpp  |  49 -
 .../Statistics/TimeDataStatisticsManager.h    |  51 --
 .../AzCore/AzCore/azcore_files.cmake          |   3 -
 Code/Framework/AzCore/Tests/Components.cpp    |   4 +-
 Code/Framework/AzCore/Tests/Math/ObbTests.cpp |  14 +-
 .../AzCore/Tests/StatisticalProfiler.cpp      | 847 ------------------
 Code/Framework/AzCore/Tests/Statistics.cpp    | 263 ------
 .../AzCore/Tests/TimeDataStatistics.cpp       | 207 -----
 .../AzCore/Tests/azcoretests_files.cmake      |   2 -
 Code/Framework/AzFramework/CMakeLists.txt     |   9 -
 .../GridMate/GridMate/Replica/ReplicaMgr.cpp  |   2 +-
 .../GridMate/GridMate/Replica/ReplicaMgr.h    |   2 +-
 .../Atom/ImageProcessing/ImageProcessingBus.h |   1 -
 .../DecalTextureArrayFeatureProcessor.cpp     |   4 +-
 .../Atom/RPI/Code/Source/RPI.Public/Scene.cpp |   2 +
 .../Code/EMotionFX/Source/MotionInstance.h    |   3 +
 .../Code/Tests/MultiplayerCompressionTest.cpp |   2 +-
 .../Code/Source/System/SystemComponent.cpp    |   2 +-
 .../Code/Editor/Nodes/NodeDisplayUtils.cpp    |  20 +-
 cmake/3rdParty/FindPIX.cmake                  |   2 +-
 .../Platform/Windows/pix_windows.cmake        |   2 +-
 28 files changed, 41 insertions(+), 2332 deletions(-)
 delete mode 100644 Code/Framework/AzCore/AzCore/Statistics/RunningStatisticsManager.cpp
 delete mode 100644 Code/Framework/AzCore/AzCore/Statistics/StatisticalProfiler.h
 delete mode 100644 Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxy.h
 delete mode 100644 Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxySystemComponent.cpp
 delete mode 100644 Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxySystemComponent.h
 delete mode 100644 Code/Framework/AzCore/AzCore/Statistics/StatisticsManager.h
 delete mode 100644 Code/Framework/AzCore/AzCore/Statistics/TimeDataStatisticsManager.cpp
 delete mode 100644 Code/Framework/AzCore/AzCore/Statistics/TimeDataStatisticsManager.h
 delete mode 100644 Code/Framework/AzCore/Tests/StatisticalProfiler.cpp
 delete mode 100644 Code/Framework/AzCore/Tests/Statistics.cpp
 delete mode 100644 Code/Framework/AzCore/Tests/TimeDataStatistics.cpp

diff --git a/Code/Framework/AzCore/AzCore/Debug/Profiler.h b/Code/Framework/AzCore/AzCore/Debug/Profiler.h
index faf511e375..5cb6142ebf 100644
--- a/Code/Framework/AzCore/AzCore/Debug/Profiler.h
+++ b/Code/Framework/AzCore/AzCore/Debug/Profiler.h
@@ -13,9 +13,6 @@
 #ifdef USE_PIX
 #include <AzCore/PlatformIncl.h>
 #include <WinPixEventRuntime/pix3.h>
-// The pix3 header unfortunately brings in other Windows macros we need to undef
-#undef DeleteFile
-#undef LoadImage
 #endif
 
 #ifdef AZ_PROFILE_TELEMETRY
@@ -32,11 +29,11 @@
  * Macro to declare a profile section for the current scope { }.
  * format is: AZ_PROFILE_SCOPE(categoryName, const char* formatStr, ...)
  */
-#   define AZ_PROFILE_SCOPE(category, formatStr, ...) ::AZ::ProfileScope AZ_JOIN(azProfileScope, __LINE__){ #category, formatStr, __VA_ARGS__ }
+#   define AZ_PROFILE_SCOPE(category, ...) ::AZ::ProfileScope AZ_JOIN(azProfileScope, __LINE__){ #category, __VA_ARGS__ }
 #   define AZ_PROFILE_FUNCTION(category) AZ_PROFILE_SCOPE(category, AZ_FUNCTION_SIGNATURE)
 
 // Prefer using the scoped macros which automatically end the event (AZ_PROFILE_SCOPE/AZ_PROFILE_FUNCTION)
-#   define AZ_PROFILE_BEGIN(category, name, ...) ::AZ::ProfileScope::BeginRegion(#category, name, __VA_ARGS__)
+#   define AZ_PROFILE_BEGIN(category, ...) ::AZ::ProfileScope::BeginRegion(#category, __VA_ARGS__)
 #   define AZ_PROFILE_END() ::AZ::ProfileScope::EndRegion()
 #endif // AZ_PROFILER_MACRO_DISABLE
 
@@ -67,14 +64,11 @@ namespace AZ
         static uint32_t GetSystemID(const char* system);
 
         template<typename... T>
-        static void BeginRegion(const char* system, char const* eventName, [[maybe_unused]] T const&... args)
+        static void BeginRegion([[maybe_unused]] const char* system, [[maybe_unused]] char const* eventName, [[maybe_unused]] T const&... args)
         {
             // TODO: Verification that the supplied system name corresponds to a known budget
 #if defined(USE_PIX)
             PIXBeginEvent(PIX_COLOR_INDEX(GetSystemID(system) & 0xff), eventName, args...);
-#else
-            (void)system;
-            (void)eventName;
 #endif
             // TODO: injecting instrumentation for other profilers
         }
@@ -395,3 +389,9 @@ namespace AZ
     }
 } // namespace AZ
 
+#ifdef USE_PIX
+// The pix3 header unfortunately brings in other Windows macros we need to undef
+#undef DeleteFile
+#undef LoadImage
+#undef GetCurrentTime
+#endif
diff --git a/Code/Framework/AzCore/AzCore/Statistics/RunningStatisticsManager.cpp b/Code/Framework/AzCore/AzCore/Statistics/RunningStatisticsManager.cpp
deleted file mode 100644
index 52085d98e7..0000000000
--- a/Code/Framework/AzCore/AzCore/Statistics/RunningStatisticsManager.cpp
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include "RunningStatisticsManager.h"
-
-namespace AzFramework
-{
-    namespace Statistics
-    {
-        bool RunningStatisticsManager::ContainsStatistic(const AZStd::string& name)
-        {
-            auto iterator = m_statisticsNamesToIndexMap.find(name);
-            return iterator != m_statisticsNamesToIndexMap.end();
-        }
-
-        bool RunningStatisticsManager::AddStatistic(const AZStd::string& name, const AZStd::string& units)
-        {
-            if (ContainsStatistic(name))
-            {
-                return false;
-            }
-            AddStatisticValidated(name, units);
-            return true;
-        }
-
-        void RunningStatisticsManager::RemoveStatistic(const AZStd::string& name)
-        {
-            auto iterator = m_statisticsNamesToIndexMap.find(name);
-            if (iterator == m_statisticsNamesToIndexMap.end())
-            {
-                return;
-            }
-            AZ::u32 itemIndex = iterator->second;
-            m_statistics.erase(m_statistics.begin() + itemIndex);
-            m_statisticsNamesToIndexMap.erase(iterator);
-            //Update the indices in m_statisticsNamesToIndexMap.
-            while (itemIndex < m_statistics.size())
-            {
-                const AZStd::string& statName = m_statistics[itemIndex].GetName();
-                m_statisticsNamesToIndexMap[statName] = itemIndex;
-                ++itemIndex;
-            }
-        }
-
-        void RunningStatisticsManager::ResetStatistic(const AZStd::string& name)
-        {
-            NamedRunningStatistic* stat = GetStatistic(name);
-            if (!stat)
-            {
-                return;
-            }
-            stat->Reset();
-        }
-
-        void RunningStatisticsManager::ResetAllStatistics()
-        {
-            for (NamedRunningStatistic& stat : m_statistics)
-            {
-                stat.Reset();
-            }
-        }
-
-        void RunningStatisticsManager::PushSampleForStatistic(const AZStd::string& name, double value)
-        {
-            NamedRunningStatistic* stat = GetStatistic(name);
-            if (!stat)
-            {
-                return;
-            }
-            stat->PushSample(value);
-        }
-
-        NamedRunningStatistic* RunningStatisticsManager::GetStatistic(const AZStd::string& name, AZ::u32* indexOut)
-        {
-            auto iterator = m_statisticsNamesToIndexMap.find(name);
-            if (iterator == m_statisticsNamesToIndexMap.end())
-            {
-                return nullptr;
-            }
-            const AZ::u32 index = iterator->second;
-            if (indexOut)
-            {
-                *indexOut = index;
-            }
-            return &m_statistics[index];
-        }
-
-        const AZStd::vector<NamedRunningStatistic>& RunningStatisticsManager::GetAllStatistics() const
-        {
-            return m_statistics;
-        }
-
-        void RunningStatisticsManager::AddStatisticValidated(const AZStd::string& name, const AZStd::string& units)
-        {
-            m_statistics.emplace_back(NamedRunningStatistic(name, units));
-            const AZ::u32 itemIndex = static_cast<AZ::u32>(m_statistics.size() - 1);
-            m_statisticsNamesToIndexMap[name] = itemIndex;
-        }
-
-    }//namespace Statistics
-}//namespace AzFramework
diff --git a/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfiler.h b/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfiler.h
deleted file mode 100644
index 2d8823c6e8..0000000000
--- a/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfiler.h
+++ /dev/null
@@ -1,255 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/EBus/BusImpl.h> //Just to get AZ::NullMutex
-#include <AzCore/std/chrono/types.h>
-#include <AzCore/Statistics/StatisticsManager.h>
-#include <AzCore/std/parallel/scoped_lock.h>
-
-namespace AZ
-{
-    namespace Statistics
-    {
-        //! A helper class that facilitates collecting time spent in blocks (scopes) of code
-        //! and aggregating the measured times as running statistics.
-        //!
-        //! See "StatisticalProfilerProxy.h" for more explanations on the meaning of Statistical Profiling.
-        //!
-        //! The StatisticalProfiler was made as a template to accommodate for several performance needs...
-        //! If all the code that is being profiled is single threaded and you want to identify
-        //! each statistic by its string name, then the default StatisticalProfiler<> works for you.
-        //! If using a map<strings, stat> is too much of what you can afford, then index your
-        //! statistics with an integer or crc32 and your code profiler should be declared as
-        //! StatisticalProfiler<AZ::Crc32>.
-        //! For multi-threaded cases and indexing statistic with Crc32 you can have a profiler like this:
-        //! StatisticalProfiler<AZ::Crc32, AZStd::mutex>.
-        //! The UnitTests mentioned in the first paragraph do benchmarks of different combinations
-        //! of indexing and synchronization primitives.
-        //!
-        //! Even though you can create, subclass and use your own StatisticalProfiler<*,*>, there
-        //! are some things to consider when working with the StatisticalProfilerProxy:
-        //! The StatisticalProfilerProxy OWNS an array of StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex>.
-        //! You can "manage" one of those StatisticalProfiler by getting a reference to it and
-        //! add Running statistics etc. See The TerrainProfilers mentioned above to see concrete use
-        //! cases on how to work with the StatisticalProfilerProxy.
-        template <class StatIdType = AZStd::string, class MutexType = AZ::NullMutex>
-        class StatisticalProfiler
-        {
-        public:
-
-            //! A Convenience class used to measure time performance of scopes of code
-            //! with constructor/destructor. Suitable to be used as part of a macro
-            //! to facilitate its usage.
-            class TimedScope
-            {
-            public:
-                TimedScope() = delete;
-
-                TimedScope(StatisticalProfiler& profiler, const StatIdType& statId)
-                    : m_profiler(profiler), m_statId(statId)
-                {
-                    m_startTime = AZStd::chrono::high_resolution_clock::now();
-                }
-
-                ~TimedScope()
-                {
-                    AZStd::chrono::system_clock::time_point stopTime = AZStd::chrono::high_resolution_clock::now();
-                    AZStd::chrono::microseconds duration = stopTime - m_startTime;
-                    m_profiler.PushSample(m_statId, static_cast<double>(duration.count()));
-                }
-
-            private:
-                StatisticalProfiler& m_profiler;
-                const StatIdType& m_statId;
-                AZStd::chrono::system_clock::time_point m_startTime;
-            }; //class TimedScope
-
-            friend class TimedScope;
-
-            StatisticalProfiler()
-            {
-            }
-
-            StatisticalProfiler(const StatisticalProfiler& other)
-            {
-                m_statisticsManager = other.m_statisticsManager;
-                m_statsVector.clear();
-                m_perFrameAggregates.clear();
-            }
-
-            StatisticalProfiler(StatisticalProfiler&& other)
-            {
-                m_statisticsManager = AZStd::move(other.m_statisticsManager);
-                m_perFrameAggregates = AZStd::move(other.m_perFrameAggregates);
-            }
-
-            virtual ~StatisticalProfiler()
-            {
-            }
-
-            AZ::Statistics::StatisticsManager<StatIdType>& GetStatsManager()
-            {
-                return m_statisticsManager;
-            }
-
-            //! Should be called once per frame, it runs over all existing timed stats in m_statsForPerFrameCalculation
-            //! and accumulates all the values as a single stat per frame.
-            double SummarizePerFrameStats()
-            {
-                AZStd::scoped_lock<MutexType> lock(m_mutex);
-
-                if (m_perFrameAggregates.size() < 1)
-                {
-                    return 0.0;
-                }
-
-                double allStatsSumMicroSecs = 0.0;
-
-                for (StatisticalAggregate& aggregate : m_perFrameAggregates)
-                {
-                    double statsSumMicroSecs = 0.0;
-                    for (const AZ::Statistics::NamedRunningStatistic* stat : aggregate.m_statsForPerFrameCalculation)
-                    {
-                        statsSumMicroSecs += stat->GetSum();
-                    }
-
-                    const double frameTime = statsSumMicroSecs - aggregate.m_prevAccumulatedSums;
-                    if (frameTime > 0.0)
-                    {
-                        aggregate.m_statPerFrame->PushSample(frameTime);
-                        aggregate.m_prevAccumulatedSums = statsSumMicroSecs;
-                    }
-                    allStatsSumMicroSecs += statsSumMicroSecs;
-                }
-
-                return allStatsSumMicroSecs;
-            }
-
-            void LogAndResetStats(const char* windowName)
-            {
-                AZStd::scoped_lock<MutexType> lock(m_mutex);
-
-                if (m_statsVector.size() != m_statisticsManager.GetCount())
-                {
-                    m_statsVector.clear();
-                    m_statisticsManager.GetAllStatistics(m_statsVector);
-                }
-
-                for (AZ::Statistics::NamedRunningStatistic* stat : m_statsVector)
-                {
-                    if (stat->GetNumSamples() == 0)
-                    {
-                        continue;
-                    }
-                    const AZStd::string& statReport = stat->GetFormatted();
-                    AZ_Printf(windowName, "%s\n", statReport.c_str());
-                    stat->Reset();
-                }
-                for (StatisticalAggregate& aggregate : m_perFrameAggregates)
-                {
-                    aggregate.m_prevAccumulatedSums = 0.0;
-                }
-            }
-
-            void PushSample(const StatIdType& statId, double value)
-            {
-                AZStd::scoped_lock<MutexType> lock(m_mutex);
-                AZ::Statistics::NamedRunningStatistic* stat = m_statisticsManager.GetStatistic(statId);
-                if (!stat)
-                {
-                    return;
-                }
-                stat->PushSample(value);
-            }
-
-            const AZ::Statistics::NamedRunningStatistic* GetStatistic(const StatIdType& statId)
-            {
-                return m_statisticsManager.GetStatistic(statId);
-            }
-
-            int AddPerFrameStatisticalAggregate(const AZStd::vector<StatIdType>& statIds,
-                const StatIdType& timePerFrameStatId,
-                const AZStd::string& timePerFrameStatName)
-            {
-                AZStd::scoped_lock<MutexType> lock(m_mutex);
-
-                m_perFrameAggregates.push_back(StatisticalAggregate());
-                StatisticalAggregate& aggregate = m_perFrameAggregates[m_perFrameAggregates.size() - 1];
-
-                int added_count = 0;
-                for (const StatIdType& statId : statIds)
-                {
-                    AZ::Statistics::NamedRunningStatistic* stat = m_statisticsManager.GetStatistic(statId);
-                    if (!stat)
-                    {
-                        continue;
-                    }
-                    auto const& itor = AZStd::find(aggregate.m_statsForPerFrameCalculation.begin(), aggregate.m_statsForPerFrameCalculation.end(), stat);
-                    if (itor != aggregate.m_statsForPerFrameCalculation.end())
-                    {
-                        continue;
-                    }
-                    aggregate.m_statsForPerFrameCalculation.push_back(stat);
-                    added_count++;
-                }
-
-                if (added_count < 1)
-                {
-                    m_perFrameAggregates.pop_back();
-                    return 0;
-                }
-
-                aggregate.m_statPerFrame = m_statisticsManager.AddStatistic(timePerFrameStatId, timePerFrameStatName, "us", true);
-                if (!aggregate.m_statPerFrame)
-                {
-                    AZ_Warning("StatisticalProfiler", false, "Per frame stat with name %s already exists\n", timePerFrameStatName.c_str());
-                    m_perFrameAggregates.pop_back();
-                    return 0;
-                }
-
-                return added_count;
-            }
-
-            const AZ::Statistics::NamedRunningStatistic* GetFirstStatPerFrame() const
-            {
-                if (m_perFrameAggregates.size() < 1)
-                {
-                    return nullptr;
-                }
-                return m_perFrameAggregates[0].m_statPerFrame;
-            }
-
-        protected:
-            //! Lock this before reading/writing to m_timeStatisticsManager, or else...
-            MutexType m_mutex;
-            AZ::Statistics::StatisticsManager<StatIdType> m_statisticsManager;
-            AZStd::vector<AZ::Statistics::NamedRunningStatistic*> m_statsVector;
-
-
-            struct StatisticalAggregate
-            {
-                StatisticalAggregate() : m_statPerFrame(nullptr), m_prevAccumulatedSums(0.0)
-                {
-
-                }
-                AZ::Statistics::NamedRunningStatistic* m_statPerFrame;
-                AZStd::vector<AZ::Statistics::NamedRunningStatistic*> m_statsForPerFrameCalculation;
-
-                //! This one is needed because running statistics are collected many times across
-                //! several frames. This value is used to calculate a per frame sample for @m_totalTimePerFrameStat,
-                //! by subtracting @m_prevAccumulatedSums from the accumulated sum in @m_statisticsManager. 
-                double m_prevAccumulatedSums;
-            };
-
-            AZStd::vector<StatisticalAggregate> m_perFrameAggregates;
-
-        }; //class StatisticalProfiler
-
-    }; //namespace Statistics
-}; //namespace AZ
diff --git a/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxy.h b/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxy.h
deleted file mode 100644
index 4f58e0cb73..0000000000
--- a/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxy.h
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/std/chrono/types.h>
-#include <AzCore/std/parallel/shared_spin_mutex.h>
-#include <AzCore/std/parallel/scoped_lock.h>
-#include <AzCore/std/containers/bitset.h>
-#include <AzCore/std/string/string.h>
-#include <AzCore/Interface/Interface.h>
-#include <AzCore/Statistics/StatisticalProfiler.h>
-#include <AzCore/Debug/Profiler.h>
-
-
-#if !defined(AZ_PROFILE_TELEMETRY) && defined(AZ_STATISTICAL_PROFILING_ENABLED)
-
-#if defined(AZ_PROFILE_SCOPE)
-#undef AZ_PROFILE_SCOPE
-#endif // #if defined(AZ_PROFILE_SCOPE)
-
-#define AZ_PROFILE_SCOPE(profiler, scopeNameId) \
-    static_assert(profiler < Count, "Invalid profiler category"); \
-    static const AZStd::string AZ_JOIN(blockName, __LINE__)(scopeNameId); \
-    AZ::Statistics::StatisticalProfilerProxy::TimedScope AZ_JOIN(scope, __LINE__)(profiler, AZ_JOIN(blockName, __LINE__));
-
-#endif //#if !defined(AZ_PROFILE_TELEMETRY)
-
-namespace AZ
-{
-    namespace Statistics
-    {
-        using StatisticalProfilerId = AZ::Name;
-
-        //! This AZ::Interface<> (Yes, it is an application wide singleton) owns an array of StatisticalProfilers.
-        //! When is this useful?
-        //! When you need to statistically profile code that runs across DLL boundaries.
-        //!
-        //! What is the meaning of "statistically profile" code?
-        //! In regular profiling with tools like RAD Telemetry, every execution of a profiled
-        //! scope of code will be captured when using AZ_PROFILE_SCOPE(). You can collect
-        //! very large amounts of data and do your own post processing and analysis in tools like Excel,etc.
-        //! In contrast, "statistical profiling" means that everytime AZ_PROFILE_SCOPE() is called,
-        //! the time spent in the given scope of code will be mathematically accumulated as part of a unique
-        //! Running statistic. Common statistical parameters like min, max, average, variance and standard deviation
-        //! are calculated on the fly. This approach reduces considerably the amount of data that is collected.
-        //! The data is recorded in the Game/Editor Log file.
-        //!
-        //! This StatisticalProfilerProxy should be used via the AZ_PROFILE_SCOPE() macro, and by using
-        //! this macro the developer gains the flexibility of switching at compile time between profiling
-        //! the code via RAD Telemetry or through statistical profiling.
-        //!
-        //! When creating a new statistical profiler add your category (aka profiler id) in Profiler.h (enum class ProfileCategory).
-        //! Get a reference of the statistical profiler with "GetProfiler(const StatisticalProfilerId& id)" using the profiler Id.
-        //! Once you get a reference to the profiler you can customize it, add Running statistics to it, etc.
-        //! Some class in your code will manage the reference to the statistical profiler and will determine
-        //! the policy on how often to log data to the game logs, etc. For example, by subclassing the TickBus Handler, etc.
-        //!
-        //! The StatisticalProfilerProxySystemComponent guarantees that the StatisticalProfilerProxy singleton exists
-        //! as soon as the AZ::Environment is fully initialized.
-        //! See StatisticalProfiler.h for more details and info.
-        class StatisticalProfilerProxy
-        {
-        public:
-            AZ_TYPE_INFO(StatisticalProfilerProxy, "{1103D0EB-1C32-4854-B9D9-40A2D65BDBD2}");
-
-            using StatIdType = AZStd::string;
-            using StatisticalProfilerType = StatisticalProfiler<StatIdType, AZStd::shared_spin_mutex>;
-
-            //! A Convenience class used to measure time performance of scopes of code
-            //! with constructor/destructor. Suitable to be used as part of a macro
-            //! to facilitate its usage.
-            class TimedScope
-            {
-            public:
-                TimedScope() = delete;
-
-                TimedScope(const StatisticalProfilerId profilerId, const StatIdType& statId)
-                    : m_profilerId(profilerId), m_statId(statId)
-                {
-                    if (!m_profilerProxy)
-                    {
-                        m_profilerProxy = AZ::Interface<StatisticalProfilerProxy>::Get();
-                        if (!m_profilerProxy)
-                        {
-                            return;
-                        }
-                    }
-                    if (!m_profilerProxy->IsProfilerActive(profilerId))
-                    {
-                        return;
-                    }
-                    m_startTime = AZStd::chrono::high_resolution_clock::now();
-                }
-                ~TimedScope()
-                {
-                    if (!m_profilerProxy)
-                    {
-                        return;
-                    }
-                    AZStd::chrono::system_clock::time_point stopTime = AZStd::chrono::high_resolution_clock::now();
-                    AZStd::chrono::microseconds duration = stopTime - m_startTime;
-                    m_profilerProxy->PushSample(m_profilerId, m_statId, static_cast<double>(duration.count()));
-                }
-
-                //! Required only for UnitTests
-                static void ClearCachedProxy()
-                {
-                    m_profilerProxy = nullptr;
-                }
-
-            private:
-                static StatisticalProfilerProxy* m_profilerProxy;
-                const StatisticalProfilerId m_profilerId;
-                const StatIdType& m_statId;
-                AZStd::chrono::system_clock::time_point m_startTime;
-            }; //class TimedScope
-
-            friend class TimedScope;
-
-            StatisticalProfilerProxy()
-            {
-                m_profilers.reserve(static_cast<AZStd::size_t>(Count));
-                for (AZStd::size_t i = 0; i < static_cast<AZStd::size_t>(Count); i++)
-                {
-                    m_profilers.emplace_back(StatisticalProfilerType());
-                }
-                AZ::Interface<StatisticalProfilerProxy>::Register(this);
-            }
-
-            virtual ~StatisticalProfilerProxy()
-            {
-                AZ::Interface<StatisticalProfilerProxy>::Unregister(this);
-            }
-
-            // Note that you have to delete these for safety reasons, you will trip a static_assert if you do not
-            StatisticalProfilerProxy(StatisticalProfilerProxy&&) = delete;
-            StatisticalProfilerProxy& operator=(StatisticalProfilerProxy&&) = delete;
-
-            bool IsProfilerActive(StatisticalProfilerId id) const
-            {
-                return m_activeProfilersFlag[static_cast<AZStd::size_t>(id)];
-            }
-
-            StatisticalProfilerType& GetProfiler(StatisticalProfilerId id)
-            {
-                return m_profilers[static_cast<AZStd::size_t>(id)];
-            }
-
-            void ActivateProfiler(StatisticalProfilerId id, bool activate)
-            {
-                m_activeProfilersFlag[static_cast<AZStd::size_t>(id)] = activate;
-            }
-
-            void PushSample(StatisticalProfilerId id, const StatIdType& statId, double value)
-            {
-                m_profilers[static_cast<AZStd::size_t>(id)].PushSample(statId, value);
-            }
-
-        private:
-            AZStd::bitset<static_cast<AZStd::size_t>(Count)> m_activeProfilersFlag;
-            AZStd::vector<StatisticalProfilerType> m_profilers;
-        }; //class StatisticalProfilerProxy
-
-    }; //namespace Statistics
-}; //namespace AZ
diff --git a/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxySystemComponent.cpp b/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxySystemComponent.cpp
deleted file mode 100644
index 00bb97b745..0000000000
--- a/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxySystemComponent.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include <AzCore/RTTI/BehaviorContext.h>
-#include <AzCore/Serialization/EditContext.h>
-#include <AzCore/Serialization/SerializeContext.h>
-#include "StatisticalProfilerProxySystemComponent.h"
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-namespace AZ
-{
-    namespace Statistics
-    {
-        StatisticalProfilerProxy* StatisticalProfilerProxy::TimedScope::m_profilerProxy = nullptr;
-
-        ////////////////////////////////////////////////////////////////////////////////////////////////
-        void StatisticalProfilerProxySystemComponent::Reflect(AZ::ReflectContext* context)
-        {
-            if (AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
-            {
-                serializeContext->Class<StatisticalProfilerProxySystemComponent, AZ::Component>()
-                    ->Version(1);
-            }
-        }
-
-        ////////////////////////////////////////////////////////////////////////////////////////////////
-        void StatisticalProfilerProxySystemComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
-        {
-            provided.push_back(AZ_CRC("StatisticalProfilerService", 0x20066f73));
-        }
-
-        ////////////////////////////////////////////////////////////////////////////////////////////////
-        void StatisticalProfilerProxySystemComponent::GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible)
-        {
-            incompatible.push_back(AZ_CRC("StatisticalProfilerService", 0x20066f73));
-        }
-
-        ////////////////////////////////////////////////////////////////////////////////////////////////
-        StatisticalProfilerProxySystemComponent::StatisticalProfilerProxySystemComponent()
-            : m_StatisticalProfilerProxy(nullptr)
-        {
-        }
-
-        ////////////////////////////////////////////////////////////////////////////////////////////////
-        StatisticalProfilerProxySystemComponent::~StatisticalProfilerProxySystemComponent()
-        {
-        }
-
-        ////////////////////////////////////////////////////////////////////////////////////////////////
-        void StatisticalProfilerProxySystemComponent::Activate()
-        {
-            m_StatisticalProfilerProxy = new StatisticalProfilerProxy;
-        }
-
-        ////////////////////////////////////////////////////////////////////////////////////////////////
-        void StatisticalProfilerProxySystemComponent::Deactivate()
-        {
-            delete m_StatisticalProfilerProxy;
-        }
-    } //namespace Statistics
-} // namespace AZ
diff --git a/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxySystemComponent.h b/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxySystemComponent.h
deleted file mode 100644
index 333e29e3b9..0000000000
--- a/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxySystemComponent.h
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Component/Component.h>
-#include "StatisticalProfilerProxy.h"
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-namespace AZ
-{
-    namespace Statistics
-    {
-        ////////////////////////////////////////////////////////////////////////////////////////////////
-        //! This system component manages the globally unique StatisticalProfilerProxy instance.
-        //! And this is all this component does... it simply makes sure the StatisticalProfilerProxy exists.
-        class StatisticalProfilerProxySystemComponent : public AZ::Component
-        {
-        public:
-            ////////////////////////////////////////////////////////////////////////////////////////////
-            // AZ::Component Setup
-            AZ_COMPONENT(StatisticalProfilerProxySystemComponent, "{1E15565F-A5C1-4BF2-8AEE-D3880AC9E1EB}")
-
-            ////////////////////////////////////////////////////////////////////////////////////////////
-            //! \ref AZ::ComponentDescriptor::Reflect
-            static void Reflect(AZ::ReflectContext* reflection);
-
-            ////////////////////////////////////////////////////////////////////////////////////////////
-            //! \ref AZ::ComponentDescriptor::GetProvidedServices
-            static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided);
-
-            ////////////////////////////////////////////////////////////////////////////////////////////
-            //! \ref AZ::ComponentDescriptor::GetIncompatibleServices
-            static void GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible);
-
-            ////////////////////////////////////////////////////////////////////////////////////////////
-            //! Constructor
-            StatisticalProfilerProxySystemComponent();
-
-            ////////////////////////////////////////////////////////////////////////////////////////////
-            //! Destructor
-            ~StatisticalProfilerProxySystemComponent() override;
-
-        protected:
-            ////////////////////////////////////////////////////////////////////////////////////////////
-            //! \ref AZ::Component::Activate
-            void Activate() override;
-
-            ////////////////////////////////////////////////////////////////////////////////////////////
-            //! \ref AZ::Component::Deactivate
-            void Deactivate() override;
-
-        private:
-            ////////////////////////////////////////////////////////////////////////////////////////////
-            // Disable copy constructor
-            StatisticalProfilerProxySystemComponent(const StatisticalProfilerProxySystemComponent&) = delete;
-
-            ////////////////////////////////////////////////////////////////////////////////////////////
-            // The one and only StatisticalProfilerProxy (Which is itself an AZ::Interface<>)
-            StatisticalProfilerProxy* m_StatisticalProfilerProxy;
-        };
-    } //namespace Statistics
-} // namespace AZ
diff --git a/Code/Framework/AzCore/AzCore/Statistics/StatisticsManager.h b/Code/Framework/AzCore/AzCore/Statistics/StatisticsManager.h
deleted file mode 100644
index 5984701f4e..0000000000
--- a/Code/Framework/AzCore/AzCore/Statistics/StatisticsManager.h
+++ /dev/null
@@ -1,200 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/std/containers/vector.h>
-#include <AzCore/std/containers/unordered_map.h>
-
-#include "NamedRunningStatistic.h"
-
-namespace AZ
-{
-    namespace Statistics
-    {
-        /**
-         * @brief A Collection of Running Statistics, addressable by a hashable
-         *        class/primitive. e.g. AZ::Crc32, int, AZStd::string, etc.
-         *
-         */
-        template <class StatIdType = AZStd::string>
-        class StatisticsManager
-        {
-        public:
-            StatisticsManager() = default;
-
-            StatisticsManager(const StatisticsManager& other)
-            {
-                m_statistics.reserve(other.m_statistics.size());
-                for (auto const& it : other.m_statistics)
-                {
-                    const StatIdType& statId = it.first;
-                    const NamedRunningStatistic* stat = it.second;
-                    m_statistics[statId] = new NamedRunningStatistic(*stat);
-                }
-            }
-
-            virtual ~StatisticsManager()
-            {
-                Clear();
-            }
-
-            bool ContainsStatistic(const StatIdType& statId) const
-            {
-                auto iterator = m_statistics.find(statId);
-                return iterator != m_statistics.end();
-            }
-
-            AZ::u32 GetCount() const
-            {
-                return static_cast<AZ::u32>(m_statistics.size());
-            }
-
-            void GetAllStatistics(AZStd::vector<NamedRunningStatistic*>& vector)
-            {
-                for (auto const& it : m_statistics)
-                {
-                    NamedRunningStatistic* stat = it.second;
-                    vector.push_back(stat);
-                }
-            }
-
-            //! Helper method to apply units to statistics with empty units string.
-            AZ::u32 ApplyUnits(const AZStd::string& units)
-            {
-                AZ::u32 updatedCount = 0;
-                for (auto& it : m_statistics)
-                {
-                    NamedRunningStatistic* stat = it.second;
-                    if (stat->GetUnits().empty())
-                    {
-                        stat->UpdateUnits(units);
-                        updatedCount++;
-                    }
-                }
-                return updatedCount;
-            }
-
-            void Clear()
-            {
-                for (auto& it : m_statistics)
-                {
-                    NamedRunningStatistic* stat = it.second;
-                    delete stat;
-                }
-                m_statistics.clear();
-            }
-
-            /**
-             * Returns nullptr if a statistic with such name doesn't exist,
-             * otherwise returns a pointer to the statistic.
-             */
-            NamedRunningStatistic* GetStatistic(const StatIdType& statId)
-            {
-                auto iterator = m_statistics.find(statId);
-                if (iterator == m_statistics.end())
-                {
-                    return nullptr;
-                }
-                return iterator->second;
-            }
-
-            //! Returns false if a NamedRunningStatistic with such id already exists.
-            NamedRunningStatistic* AddStatistic(const StatIdType& statId, const bool failIfExist = true)
-            {
-                if (failIfExist)
-                {
-                    NamedRunningStatistic* prevStat = GetStatistic(statId);
-                    if (prevStat)
-                    {
-                        return nullptr;
-                    }
-                }
-                NamedRunningStatistic* stat = new NamedRunningStatistic();
-                m_statistics[statId] = stat;
-                return stat;
-            }
-
-            //! Returns false if a NamedRunningStatistic with such id already exists.
-            NamedRunningStatistic* AddStatistic(const StatIdType& statId, const AZStd::string& name, const AZStd::string& units, const bool failIfExist = true)
-            {
-                if (failIfExist)
-                {
-                    NamedRunningStatistic* prevStat = GetStatistic(statId);
-                    if (prevStat)
-                    {
-                        return nullptr;
-                    }
-                }
-                NamedRunningStatistic* stat = new NamedRunningStatistic(name, units);
-                m_statistics[statId] = stat;
-                return stat;
-            }
-
-            virtual void RemoveStatistic(const StatIdType& statId)
-            {
-                auto iterator = m_statistics.find(statId);
-                if (iterator == m_statistics.end())
-                {
-                    return;
-                }
-                NamedRunningStatistic* prevStat = iterator->second;
-                delete prevStat;
-                m_statistics.erase(iterator);
-            }
-
-            void ResetStatistic(const StatIdType& statId)
-            {
-                NamedRunningStatistic* stat = GetStatistic(statId);
-                if (!stat)
-                {
-                    return;
-                }
-                stat->Reset();
-            }
-
-            void ResetAllStatistics()
-            {
-                for (auto& it : m_statistics)
-                {
-                    NamedRunningStatistic* stat = it.second;
-                    stat->Reset();
-                }
-            }
-
-            void PushSampleForStatistic(const StatIdType& statId, double value)
-            {
-                NamedRunningStatistic* stat = GetStatistic(statId);
-                if (!stat)
-                {
-                    return;
-                }
-                stat->PushSample(value);
-            }
-
-            //! Expensive function because it does a reverse lookup
-            bool GetStatId(NamedRunningStatistic* searchStat, StatIdType& statIdOut) const
-            {
-                for (auto& it : m_statistics)
-                {
-                    NamedRunningStatistic* stat = it.second;
-                    if (stat == searchStat)
-                    {
-                        statIdOut = it.first;
-                        return true;
-                    }
-                }
-                return false;
-            }
-
-
-        private:
-            ///Key: StatIdType, Value: NamedRunningStatistic*
-            AZStd::unordered_map<StatIdType, NamedRunningStatistic*> m_statistics;
-        };//class StatisticsManager
-    }//namespace Statistics
-}//namespace AZ
diff --git a/Code/Framework/AzCore/AzCore/Statistics/TimeDataStatisticsManager.cpp b/Code/Framework/AzCore/AzCore/Statistics/TimeDataStatisticsManager.cpp
deleted file mode 100644
index 0e9b36a8b6..0000000000
--- a/Code/Framework/AzCore/AzCore/Statistics/TimeDataStatisticsManager.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include "TimeDataStatisticsManager.h"
-
-namespace AZ
-{
-    namespace Statistics
-    {
-        void TimeDataStatisticsManager::PushTimeDataSample(const char * registerName, const AZ::Debug::ProfilerRegister::TimeData& timeData)
-        {
-            const AZStd::string statName(registerName);
-            NamedRunningStatistic* statistic = GetStatistic(statName);
-            if (!statistic)
-            {
-                const AZStd::string units("us");
-                AddStatistic(statName, statName, units, false);
-                AZ::Debug::ProfilerRegister::TimeData zeroTimeData;
-                memset(&zeroTimeData, 0, sizeof(AZ::Debug::ProfilerRegister::TimeData));
-                m_previousTimeData[statName] = zeroTimeData;
-                statistic = GetStatistic(statName);
-                AZ_Assert(statistic != nullptr, "Fatal error adding a new statistic object");
-            }
-
-            const AZ::u64 accumulatedTime = timeData.m_time;
-            const AZ::s64 totalNumCalls = timeData.m_calls;
-            const AZ::u64 previousAccumulatedTime = m_previousTimeData[statName].m_time;
-            const AZ::s64 previousTotalNumCalls = m_previousTimeData[statName].m_calls;
-            const AZ::u64 deltaTime = accumulatedTime - previousAccumulatedTime;
-            const AZ::s64 deltaCalls = totalNumCalls - previousTotalNumCalls;
-            
-            if (deltaCalls == 0)
-            {
-                //This is the same old data. Let's skip it
-                return;
-            }
-
-            double newSample = static_cast<double>(deltaTime) / deltaCalls;
-
-            statistic->PushSample(newSample);
-            m_previousTimeData[statName] = timeData;
-        }
-    } //namespace Statistics
-} //namespace AZ
diff --git a/Code/Framework/AzCore/AzCore/Statistics/TimeDataStatisticsManager.h b/Code/Framework/AzCore/AzCore/Statistics/TimeDataStatisticsManager.h
deleted file mode 100644
index 4b5c58f426..0000000000
--- a/Code/Framework/AzCore/AzCore/Statistics/TimeDataStatisticsManager.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#include <AzCore/Debug/Profiler.h>
-#include <AzCore/Statistics/StatisticsManager.h>
-
-namespace AZ
-{
-    namespace Statistics
-    {
-        /**
-         * @brief Specialization useful for data generated with AZ::Debug::FrameProfileComponent
-         *
-         * Timer based data collection using AZ_PROFILE_SCOPE(...), available in
-         * AzCore/Debug/Profiler.h can be collected when using AZ::Debug::FrameProfilerComponent
-         * and AZ::Debug::FrameProfilerBus. The method PushTimeDataSample(...) is a convenience
-         * to convert those Timer registers into a RunningStatistic.
-         *
-         * 
-         */
-        class TimeDataStatisticsManager : public StatisticsManager<>
-        {
-        public:
-            TimeDataStatisticsManager() = default;
-            virtual ~TimeDataStatisticsManager() = default;
-
-            /**
-             * @brief Adds one sample data to a specific running stat by name.
-             *
-             * This method is specialized to work with ProfilerRegister::TimeData that can be intercepted
-             * during AZ::Debug::FrameProfilerBus::OnFrameProfilerData().
-             * For each @param registerName a new RunningStat object is created if it doesn't exist.
-             *
-             * Adds the TimeData as one sample for its RunningStatistic.
-             */
-            void PushTimeDataSample(const char * registerName, const AZ::Debug::ProfilerRegister::TimeData& timeData);
-
-        protected:
-            ///We store here the previous value from the previous timer frame data.
-            ///This is necessary because AZ_PROFILER_TIMER is cumulative
-            ///and we need the time spent for each call.
-            AZStd::unordered_map<AZStd::string, AZ::Debug::ProfilerRegister::TimeData> m_previousTimeData;
-        };
-    } //namespace Statistics
-} //namespace AZ
diff --git a/Code/Framework/AzCore/AzCore/azcore_files.cmake b/Code/Framework/AzCore/AzCore/azcore_files.cmake
index 79d3e321ec..c49c93f220 100644
--- a/Code/Framework/AzCore/AzCore/azcore_files.cmake
+++ b/Code/Framework/AzCore/AzCore/azcore_files.cmake
@@ -566,9 +566,6 @@ set(FILES
     Statistics/NamedRunningStatistic.h
     Statistics/RunningStatistic.cpp
     Statistics/RunningStatistic.h
-    Statistics/StatisticsManager.h
-    Statistics/TimeDataStatisticsManager.cpp
-    Statistics/TimeDataStatisticsManager.h
     StringFunc/StringFunc.cpp
     StringFunc/StringFunc.h
     UserSettings/UserSettings.cpp
diff --git a/Code/Framework/AzCore/Tests/Components.cpp b/Code/Framework/AzCore/Tests/Components.cpp
index 45193f4d1e..37bb783642 100644
--- a/Code/Framework/AzCore/Tests/Components.cpp
+++ b/Code/Framework/AzCore/Tests/Components.cpp
@@ -1255,7 +1255,7 @@ namespace UnitTest
 
         int ChildFunction1(int input)
         {
-            AZ_PROFILE_SCOPE(System, "Child1");
+            AZ_PROFILE_SCOPE(AzCore, "Child1");
             int result = 5;
             for (int i = 0; i < 10000; ++i)
             {
@@ -1266,7 +1266,7 @@ namespace UnitTest
 
         int Profile1(int numIterations)
         {
-            AZ_PROFILE_SCOPE(System, "Custom name");
+            AZ_PROFILE_SCOPE(AzCore, "Custom name");
             int result = 0;
             for (int i = 0; i < numIterations; ++i)
             {
diff --git a/Code/Framework/AzCore/Tests/Math/ObbTests.cpp b/Code/Framework/AzCore/Tests/Math/ObbTests.cpp
index b0012ee93c..de285343f6 100644
--- a/Code/Framework/AzCore/Tests/Math/ObbTests.cpp
+++ b/Code/Framework/AzCore/Tests/Math/ObbTests.cpp
@@ -6,16 +6,16 @@
  *
  */
 
-#include <AzCore/Math/Obb.h>
-#include <AzCore/Math/Aabb.h>
-#include <AzCore/Math/Vector3.h>
-#include <AzCore/Math/Transform.h>
-#include <AzCore/UnitTest/TestTypes.h>
 #include <AZTestShared/Math/MathTestHelpers.h>
+#include <AzCore/Math/Aabb.h>
+#include <AzCore/Math/Obb.h>
+#include <AzCore/Math/Transform.h>
+#include <AzCore/Math/Vector3.h>
+#include <AzCore/UnitTest/TestTypes.h>
 
 using namespace AZ;
 
-namespace UnitTest
+namespace UnitTest::ObbTests
 {
     const Vector3 position(1.0f, 2.0f, 3.0f);
     const Quaternion rotation = Quaternion::CreateRotationZ(Constants::QuarterPi);
@@ -151,4 +151,4 @@ namespace UnitTest
         EXPECT_NEAR(obb.GetDistanceSq(Vector3(2.4f, 0.5f, 1.5f)), 0.5532f, 1e-3f);
         EXPECT_NEAR(obb.GetDistanceSq(Vector3(1.1f, 7.3f, 5.8f)), 1.3612f, 1e-3f);
     }
-}
+} // namespace UnitTest::ObbTests
diff --git a/Code/Framework/AzCore/Tests/StatisticalProfiler.cpp b/Code/Framework/AzCore/Tests/StatisticalProfiler.cpp
deleted file mode 100644
index 6d6023b872..0000000000
--- a/Code/Framework/AzCore/Tests/StatisticalProfiler.cpp
+++ /dev/null
@@ -1,847 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#include <AzCore/UnitTest/TestTypes.h>
-#include <AzCore/UnitTest/UnitTest.h>
-#include <AzTest/AzTest.h>
-
-#include <AzCore/Math/Crc.h>
-#include <AzCore/std/string/string.h>
-#include <AzCore/std/parallel/thread.h>
-#include <AzCore/std/parallel/shared_spin_mutex.h>
-#include <AzCore/Debug/TraceMessagesDrillerBus.h>
-
-#include <AzCore/Statistics/StatisticalProfilerProxy.h>
-
-//REMARK: The macros CODE_PROFILER_PROXY_PUSH_TIME and CODE_PROFILER_PUSH_TIME will be redefined
-//several times in this file to accommodate for the different specializations of the StatisticalProfiler<>
-//template.
-#ifdef CODE_PROFILER_PROXY_PUSH_TIME
-#undef CODE_PROFILER_PROXY_PUSH_TIME
-#endif
-
-#ifdef CODE_PROFILER_PUSH_TIME
-#undef CODE_PROFILER_PUSH_TIME
-#endif
-
-namespace UnitTest
-{
-    class StatisticalProfilerTest
-        : public AllocatorsFixture
-    {
-    public:
-
-        StatisticalProfilerTest()
-        {
-        }
-
-        void SetUp() override
-        {
-            AllocatorsFixture::SetUp();
-        }
-
-        ~StatisticalProfilerTest()
-        {
-        }
-
-        void TearDown() override
-        {
-            AllocatorsFixture::TearDown();
-        }
-
-    }; //class StatisticalProfilerTest
-
-    TEST_F(StatisticalProfilerTest, StatisticalProfilerStringNoMutex_ProfileCode_ValidateStatistics)
-    {
-//Helper macro.
-#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
-    AZ::Statistics::StatisticalProfiler<>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
-
-        AZ::Statistics::StatisticalProfiler<> profiler;
-
-        const AZStd::string statNamePerformance("PerformanceResult");
-        const AZStd::string statNameBlock("Block");
-
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNamePerformance, statNamePerformance, "us") != nullptr);
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNameBlock, statNameBlock, "us") != nullptr);
-
-        const int iter_count = 10;
-        {
-            CODE_PROFILER_PUSH_TIME(profiler, statNamePerformance)
-                int counter = 0;
-            for (int i = 0; i < iter_count; i++)
-            {
-                CODE_PROFILER_PUSH_TIME(profiler, statNameBlock)
-                    counter++;
-            }
-        }
-
-        ASSERT_TRUE(profiler.GetStatistic(statNamePerformance) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statNamePerformance)->GetNumSamples(), 1);
-
-        ASSERT_TRUE(profiler.GetStatistic(statNameBlock) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statNameBlock)->GetNumSamples(), iter_count);
-
-#undef CODE_PROFILER_PUSH_TIME
-
-    }
-
-    TEST_F(StatisticalProfilerTest, StatisticalProfilerCrc32NoMutex_ProfileCode_ValidateStatistics)
-    {
-        //Helper macro.
-#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
-    AZ::Statistics::StatisticalProfiler<AZ::Crc32>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
-
-        AZ::Statistics::StatisticalProfiler<AZ::Crc32> profiler;
-
-        const AZ::Crc32 statIdPerformance = AZ_CRC("PerformanceResult", 0xc1f29a10);
-        const AZStd::string statNamePerformance("PerformanceResult");
-
-        const AZ::Crc32 statIdBlock = AZ_CRC("Block", 0x831b9722);
-        const AZStd::string statNameBlock("Block");
-
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdPerformance, statNamePerformance, "us") != nullptr);
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdBlock, statNameBlock, "us") != nullptr);
-
-        const int iter_count = 10;
-        {
-            CODE_PROFILER_PUSH_TIME(profiler, statIdPerformance)
-                int counter = 0;
-            for (int i = 0; i < iter_count; i++)
-            {
-                CODE_PROFILER_PUSH_TIME(profiler, statIdBlock)
-                    counter++;
-            }
-        }
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdPerformance)->GetNumSamples(), 1);
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdBlock) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdBlock)->GetNumSamples(), iter_count);
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
-
-#undef CODE_PROFILER_PUSH_TIME
-
-    }
-
-    TEST_F(StatisticalProfilerTest, StatisticalProfilerStringWithSharedSpinMutex__ProfileCode_ValidateStatistics)
-    {
-        //Helper macro.
-#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
-    AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
-
-        AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex> profiler;
-
-        const AZStd::string statNamePerformance("PerformanceResult");
-        const AZStd::string statNameBlock("Block");
-
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNamePerformance, statNamePerformance, "us") != nullptr);
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNameBlock, statNameBlock, "us") != nullptr);
-
-        const int iter_count = 10;
-        {
-            CODE_PROFILER_PUSH_TIME(profiler, statNamePerformance)
-                int counter = 0;
-            for (int i = 0; i < iter_count; i++)
-            {
-                CODE_PROFILER_PUSH_TIME(profiler, statNameBlock)
-                    counter++;
-            }
-        }
-
-        ASSERT_TRUE(profiler.GetStatistic(statNamePerformance) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statNamePerformance)->GetNumSamples(), 1);
-
-        ASSERT_TRUE(profiler.GetStatistic(statNameBlock) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statNameBlock)->GetNumSamples(), iter_count);
-
-        ASSERT_TRUE(profiler.GetStatistic(statNamePerformance) != nullptr);
-
-#undef CODE_PROFILER_PUSH_TIME
-
-    }
-
-    TEST_F(StatisticalProfilerTest, StatisticalProfilerCrc32WithSharedSpinMutex__ProfileCode_ValidateStatistics)
-    {
-        //Helper macro.
-#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
-    AZ::Statistics::StatisticalProfiler<AZ::Crc32, AZStd::shared_spin_mutex>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
-
-        AZ::Statistics::StatisticalProfiler<AZ::Crc32, AZStd::shared_spin_mutex> profiler;
-
-        const AZ::Crc32 statIdPerformance = AZ_CRC("PerformanceResult", 0xc1f29a10);
-        const AZStd::string statNamePerformance("PerformanceResult");
-
-        const AZ::Crc32 statIdBlock = AZ_CRC("Block", 0x831b9722);
-        const AZStd::string statNameBlock("Block");
-
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdPerformance, statNamePerformance, "us") != nullptr);
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdBlock, statNameBlock, "us") != nullptr);
-
-        const int iter_count = 10;
-        {
-            CODE_PROFILER_PUSH_TIME(profiler, statIdPerformance)
-                int counter = 0;
-            for (int i = 0; i < iter_count; i++)
-            {
-                CODE_PROFILER_PUSH_TIME(profiler, statIdBlock)
-                    counter++;
-            }
-        }
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdPerformance)->GetNumSamples(), 1);
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdBlock) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdBlock)->GetNumSamples(), iter_count);
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
-
-#undef CODE_PROFILER_PUSH_TIME
-
-    }
-
-#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
-    AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
-
-    static void simple_thread01(AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex>* profiler, int loop_cnt)
-    {
-        const AZStd::string simple_thread("simple_thread1");
-        const AZStd::string simple_thread_loop("simple_thread1_loop");
-
-        CODE_PROFILER_PUSH_TIME(*profiler, simple_thread);
-
-        static int counter = 0;
-        for (int i = 0; i < loop_cnt; i++)
-        {
-            CODE_PROFILER_PUSH_TIME(*profiler, simple_thread_loop);
-            counter++;
-        }
-    }
-
-    static void simple_thread02(AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex>* profiler, int loop_cnt)
-    {
-        const AZStd::string simple_thread("simple_thread2");
-        const AZStd::string simple_thread_loop("simple_thread2_loop");
-
-        CODE_PROFILER_PUSH_TIME(*profiler, simple_thread);
-
-        static int counter = 0;
-        for (int i = 0; i < loop_cnt; i++)
-        {
-            CODE_PROFILER_PUSH_TIME(*profiler, simple_thread_loop);
-            counter++;
-        }
-    }
-
-    static void simple_thread03(AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex>* profiler, int loop_cnt)
-    {
-        const AZStd::string simple_thread("simple_thread3");
-        const AZStd::string simple_thread_loop("simple_thread3_loop");
-
-        CODE_PROFILER_PUSH_TIME(*profiler, simple_thread);
-
-        static int counter = 0;
-        for (int i = 0; i < loop_cnt; i++)
-        {
-            CODE_PROFILER_PUSH_TIME(*profiler, simple_thread_loop);
-            counter++;
-        }
-    }
-
-#undef CODE_PROFILER_PUSH_TIME
-
-    TEST_F(StatisticalProfilerTest, StatisticalProfilerStringWithSharedSpinMutex_RunProfiledThreads_ValidateStatistics)
-    {
-        AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex> profiler;
-
-        const AZStd::string statIdThread1 = "simple_thread1";
-        const AZStd::string statNameThread1("simple_thread1");
-        const AZStd::string statIdThread1Loop = "simple_thread1_loop";
-        const AZStd::string statNameThread1Loop("simple_thread1_loop");
-
-        const AZStd::string statIdThread2 = "simple_thread2";
-        const AZStd::string statNameThread2("simple_thread2");
-        const AZStd::string statIdThread2Loop = "simple_thread2_loop";
-        const AZStd::string statNameThread2Loop("simple_thread2_loop");
-
-        const AZStd::string statIdThread3 = "simple_thread3";
-        const AZStd::string statNameThread3("simple_thread3");
-        const AZStd::string statIdThread3Loop = "simple_thread3_loop";
-        const AZStd::string statNameThread3Loop("simple_thread3_loop");
-
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1, statNameThread1, "us"));
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1Loop, statNameThread1Loop, "us"));
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2, statNameThread2, "us"));
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2Loop, statNameThread2Loop, "us"));
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3, statNameThread3, "us"));
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3Loop, statNameThread3Loop, "us"));
-
-        //Let's kickoff the threads to see how much contention affects the profiler's performance.
-        const int iter_count = 10;
-        AZStd::thread t1(AZStd::bind(&simple_thread01, &profiler, iter_count));
-        AZStd::thread t2(AZStd::bind(&simple_thread02, &profiler, iter_count));
-        AZStd::thread t3(AZStd::bind(&simple_thread03, &profiler, iter_count));
-        t1.join();
-        t2.join();
-        t3.join();
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread1) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread1)->GetNumSamples(), 1);
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread1Loop) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread1Loop)->GetNumSamples(), iter_count);
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread2) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread2)->GetNumSamples(), 1);
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread2Loop) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread2Loop)->GetNumSamples(), iter_count);
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread3) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread3)->GetNumSamples(), 1);
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread3Loop) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread3Loop)->GetNumSamples(), iter_count);
-
-    }
-
-    TEST_F(StatisticalProfilerTest, StatisticalProfilerProxy_ProfileCode_ValidateStatistics)
-    {
-#define CODE_PROFILER_PROXY_PUSH_TIME(profiler, scopeNameId) \
-    AZ::Statistics::StatisticalProfilerProxy::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
-
-        AZ::Statistics::StatisticalProfilerProxy::TimedScope::ClearCachedProxy();
-        AZ::Statistics::StatisticalProfilerProxy profilerProxy;
-        AZ::Statistics::StatisticalProfilerProxy* proxy = AZ::Interface<AZ::Statistics::StatisticalProfilerProxy>::Get();
-        AZ::Statistics::StatisticalProfilerProxy::StatisticalProfilerType& profiler = proxy->GetProfiler(Terrain);
-
-        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdPerformance = "PerformanceResult";
-        const AZStd::string statNamePerformance("PerformanceResult");
-
-        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdBlock = "Block";
-        const AZStd::string statNameBlock("Block");
-
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdPerformance, statNamePerformance, "us") != nullptr);
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdBlock, statNameBlock, "us") != nullptr);
-
-        proxy->ActivateProfiler(Terrain, true);
-
-        const int iter_count = 10;
-        {
-            CODE_PROFILER_PROXY_PUSH_TIME(Terrain, statIdPerformance)
-            int counter = 0;
-            for (int i = 0; i < iter_count; i++)
-            {
-                CODE_PROFILER_PROXY_PUSH_TIME(Terrain, statIdBlock)
-                    counter++;
-            }
-        }
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdPerformance)->GetNumSamples(), 1);
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdBlock) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdBlock)->GetNumSamples(), iter_count);
-
-        //Clean Up
-        proxy->ActivateProfiler(Terrain, false);
-
-#undef CODE_PROFILER_PROXY_PUSH_TIME
-
-    }
-
-#define CODE_PROFILER_PROXY_PUSH_TIME(profiler, scopeNameId) \
-    AZ::Statistics::StatisticalProfilerProxy::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
-
-    static void simple_thread1(int loop_cnt)
-    {
-        const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread1("simple_thread1");
-        const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread1_loop("simple_thread1_loop");
-
-        CODE_PROFILER_PROXY_PUSH_TIME(Terrain, simple_thread1);
-
-        static int counter = 0;
-        for (int i = 0; i < loop_cnt; i++)
-        {
-            CODE_PROFILER_PROXY_PUSH_TIME(Terrain, simple_thread1_loop);
-            counter++;
-        }
-    }
-
-    static void simple_thread2(int loop_cnt)
-    {
-        const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread2("simple_thread2");
-        const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread2_loop("simple_thread2_loop");
-
-        CODE_PROFILER_PROXY_PUSH_TIME(Terrain, simple_thread2);
-
-        static int counter = 0;
-        for (int i = 0; i < loop_cnt; i++)
-        {
-            CODE_PROFILER_PROXY_PUSH_TIME(Terrain, simple_thread2_loop);
-            counter++;
-        }
-    }
-
-    static void simple_thread3(int loop_cnt)
-    {
-        const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread3("simple_thread3");
-        const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread3_loop("simple_thread3_loop");
-
-        CODE_PROFILER_PROXY_PUSH_TIME(Terrain, simple_thread3);
-
-        static int counter = 0;
-        for (int i = 0; i < loop_cnt; i++)
-        {
-            CODE_PROFILER_PROXY_PUSH_TIME(Terrain, simple_thread3_loop);
-        }
-    }
-
-#undef CODE_PROFILER_PROXY_PUSH_TIME
-
-    TEST_F(StatisticalProfilerTest, StatisticalProfilerProxy3_RunProfiledThreads_ValidateStatistics)
-    {
-        AZ::Statistics::StatisticalProfilerProxy::TimedScope::ClearCachedProxy();
-        AZ::Statistics::StatisticalProfilerProxy profilerProxy;
-        AZ::Statistics::StatisticalProfilerProxy* proxy = AZ::Interface<AZ::Statistics::StatisticalProfilerProxy>::Get();
-        AZ::Statistics::StatisticalProfilerProxy::StatisticalProfilerType& profiler = proxy->GetProfiler(Terrain);
-
-        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread1 = "simple_thread1";
-        const AZStd::string statNameThread1("simple_thread1");
-        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread1Loop = "simple_thread1_loop";
-        const AZStd::string statNameThread1Loop("simple_thread1_loop");
-
-        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread2 = "simple_thread2";
-        const AZStd::string statNameThread2("simple_thread2");
-        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread2Loop = "simple_thread2_loop";
-        const AZStd::string statNameThread2Loop("simple_thread2_loop");
-
-        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread3 = "simple_thread3";
-        const AZStd::string statNameThread3("simple_thread3");
-        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread3Loop = "simple_thread3_loop";
-        const AZStd::string statNameThread3Loop("simple_thread3_loop");
-
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1, statNameThread1, "us"));
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1Loop, statNameThread1Loop, "us"));
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2, statNameThread2, "us"));
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2Loop, statNameThread2Loop, "us"));
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3, statNameThread3, "us"));
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3Loop, statNameThread3Loop, "us"));
-
-        proxy->ActivateProfiler(Terrain, true);
-
-        //Let's kickoff the threads to see how much contention affects the profiler's performance.
-        const int iter_count = 10;
-        AZStd::thread t1(AZStd::bind(&simple_thread1, iter_count));
-        AZStd::thread t2(AZStd::bind(&simple_thread2, iter_count));
-        AZStd::thread t3(AZStd::bind(&simple_thread3, iter_count));
-        t1.join();
-        t2.join();
-        t3.join();
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread1) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread1)->GetNumSamples(), 1);
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread1Loop) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread1Loop)->GetNumSamples(), iter_count);
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread2) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread2)->GetNumSamples(), 1);
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread2Loop) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread2Loop)->GetNumSamples(), iter_count);
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread3) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread3)->GetNumSamples(), 1);
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread3Loop) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread3Loop)->GetNumSamples(), iter_count);
-
-        //Clean Up
-        proxy->ActivateProfiler(Terrain, false);
-    }
-
-    /** Trace message handler to track messages during tests
-*/
-    struct MyTraceMessageSink final
-        : public AZ::Debug::TraceMessageDrillerBus::Handler
-    {
-        MyTraceMessageSink()
-        {
-            AZ::Debug::TraceMessageDrillerBus::Handler::BusConnect();
-        }
-
-        ~MyTraceMessageSink()
-        {
-            AZ::Debug::TraceMessageDrillerBus::Handler::BusDisconnect();
-        }
-
-        //////////////////////////////////////////////////////////////////////////
-        // TraceMessageDrillerBus
-        void OnPrintf(const char* window, const char* message) override
-        {
-            OnOutput(window, message);
-        }
-
-        void OnOutput(const char* window, const char* message) override
-        {
-            printf("%s: %s\n", window, message);
-        }
-    }; //struct MyTraceMessageSink
-
-    class Suite_StatisticalProfilerPerformance
-        : public AllocatorsFixture
-    {
-    public:
-        MyTraceMessageSink* m_testSink;
-
-        Suite_StatisticalProfilerPerformance() :m_testSink(nullptr)
-        {
-        }
-
-        void SetUp() override
-        {
-            AllocatorsFixture::SetUp();
-            m_testSink = new MyTraceMessageSink();
-        }
-
-        ~Suite_StatisticalProfilerPerformance()
-        {
-        }
-
-        void TearDown() override
-        {
-            // clearing up memory
-            delete m_testSink;
-            AllocatorsFixture::TearDown();
-        }
-
-    }; //class Suite_StatisticalProfilerPerformance
-
-    TEST_F(Suite_StatisticalProfilerPerformance, StatisticalProfilerStringNoMutex_1ThreadPerformance)
-    {
-        //Helper macro.
-#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
-    AZ::Statistics::StatisticalProfiler<>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
-
-        AZ::Statistics::StatisticalProfiler<> profiler;
-
-        const AZStd::string statNamePerformance("PerformanceResult");
-        const AZStd::string statNameBlock("Block");
-
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNamePerformance, statNamePerformance, "us") != nullptr);
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNameBlock, statNameBlock, "us") != nullptr);
-
-        const int iter_count = 1000000;
-        {
-            CODE_PROFILER_PUSH_TIME(profiler, statNamePerformance)
-                int counter = 0;
-            for (int i = 0; i < iter_count; i++)
-            {
-                CODE_PROFILER_PUSH_TIME(profiler, statNameBlock)
-                    counter++;
-            }
-        }
-
-        ASSERT_TRUE(profiler.GetStatistic(statNamePerformance) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statNamePerformance)->GetNumSamples(), 1);
-
-        ASSERT_TRUE(profiler.GetStatistic(statNameBlock) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statNameBlock)->GetNumSamples(), iter_count);
-
-        profiler.LogAndResetStats("StatisticalProfilerStringNoMutex");
-
-        ASSERT_TRUE(profiler.GetStatistic(statNamePerformance) != nullptr);
-
-#undef CODE_PROFILER_PUSH_TIME
-
-    }
-
-    TEST_F(Suite_StatisticalProfilerPerformance, StatisticalProfilerCrc32NoMutex_1ThreadPerformance)
-    {
-        //Helper macro.
-#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
-    AZ::Statistics::StatisticalProfiler<AZ::Crc32>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
-
-        AZ::Statistics::StatisticalProfiler<AZ::Crc32> profiler;
-
-        const AZ::Crc32 statIdPerformance = AZ_CRC("PerformanceResult", 0xc1f29a10);
-        const AZStd::string statNamePerformance("PerformanceResult");
-
-        const AZ::Crc32 statIdBlock = AZ_CRC("Block", 0x831b9722);
-        const AZStd::string statNameBlock("Block");
-
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdPerformance, statNamePerformance, "us") != nullptr);
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdBlock, statNameBlock, "us") != nullptr);
-
-        const int iter_count = 1000000;
-        {
-            CODE_PROFILER_PUSH_TIME(profiler, statIdPerformance)
-                int counter = 0;
-            for (int i = 0; i < iter_count; i++)
-            {
-                CODE_PROFILER_PUSH_TIME(profiler, statIdBlock)
-                    counter++;
-            }
-        }
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdPerformance)->GetNumSamples(), 1);
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdBlock) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdBlock)->GetNumSamples(), iter_count);
-
-        profiler.LogAndResetStats("StatisticalProfilerCrc32NoMutex");
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
-
-#undef CODE_PROFILER_PUSH_TIME
-
-    }
-
-    TEST_F(Suite_StatisticalProfilerPerformance, StatisticalProfilerStringWithSharedSpinMutex_1ThreadPerformance)
-    {
-        //Helper macro.
-#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
-    AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
-
-        AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex> profiler;
-
-        const AZStd::string statNamePerformance("PerformanceResult");
-        const AZStd::string statNameBlock("Block");
-
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNamePerformance, statNamePerformance, "us") != nullptr);
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNameBlock, statNameBlock, "us") != nullptr);
-
-        const int iter_count = 1000000;
-        {
-            CODE_PROFILER_PUSH_TIME(profiler, statNamePerformance)
-                int counter = 0;
-            for (int i = 0; i < iter_count; i++)
-            {
-                CODE_PROFILER_PUSH_TIME(profiler, statNameBlock)
-                    counter++;
-            }
-        }
-
-        ASSERT_TRUE(profiler.GetStatistic(statNamePerformance) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statNamePerformance)->GetNumSamples(), 1);
-
-        ASSERT_TRUE(profiler.GetStatistic(statNameBlock) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statNameBlock)->GetNumSamples(), iter_count);
-
-        profiler.LogAndResetStats("StatisticalProfilerStringWithSharedSpinMutex");
-
-        ASSERT_TRUE(profiler.GetStatistic(statNamePerformance) != nullptr);
-
-#undef CODE_PROFILER_PUSH_TIME
-
-    }
-
-    TEST_F(Suite_StatisticalProfilerPerformance, StatisticalProfilerCrc32WithSharedSpinMutex_1ThreadPerformance)
-    {
-        //Helper macro.
-#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
-    AZ::Statistics::StatisticalProfiler<AZ::Crc32, AZStd::shared_spin_mutex>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
-
-        AZ::Statistics::StatisticalProfiler<AZ::Crc32, AZStd::shared_spin_mutex> profiler;
-
-        const AZ::Crc32 statIdPerformance = AZ_CRC("PerformanceResult", 0xc1f29a10);
-        const AZStd::string statNamePerformance("PerformanceResult");
-
-        const AZ::Crc32 statIdBlock = AZ_CRC("Block", 0x831b9722);
-        const AZStd::string statNameBlock("Block");
-
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdPerformance, statNamePerformance, "us") != nullptr);
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdBlock, statNameBlock, "us") != nullptr);
-
-        const int iter_count = 1000000;
-        {
-            CODE_PROFILER_PUSH_TIME(profiler, statIdPerformance)
-                int counter = 0;
-            for (int i = 0; i < iter_count; i++)
-            {
-                CODE_PROFILER_PUSH_TIME(profiler, statIdBlock)
-                    counter++;
-            }
-        }
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdPerformance)->GetNumSamples(), 1);
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdBlock) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdBlock)->GetNumSamples(), iter_count);
-
-        profiler.LogAndResetStats("StatisticalProfilerCrc32WithSharedSpinMutex");
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
-
-#undef CODE_PROFILER_PUSH_TIME
-
-    }
-
-    TEST_F(Suite_StatisticalProfilerPerformance, StatisticalProfilerStringWithSharedSpinMutex3Threads_3ThreadsPerformance)
-    {
-        AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex> profiler;
-
-        const AZStd::string statIdThread1 = "simple_thread1";
-        const AZStd::string statNameThread1("simple_thread1");
-        const AZStd::string statIdThread1Loop = "simple_thread1_loop";
-        const AZStd::string statNameThread1Loop("simple_thread1_loop");
-
-        const AZStd::string statIdThread2 = "simple_thread2";
-        const AZStd::string statNameThread2("simple_thread2");
-        const AZStd::string statIdThread2Loop = "simple_thread2_loop";
-        const AZStd::string statNameThread2Loop("simple_thread2_loop");
-
-        const AZStd::string statIdThread3 = "simple_thread3";
-        const AZStd::string statNameThread3("simple_thread3");
-        const AZStd::string statIdThread3Loop = "simple_thread3_loop";
-        const AZStd::string statNameThread3Loop("simple_thread3_loop");
-
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1, statNameThread1, "us"));
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1Loop, statNameThread1Loop, "us"));
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2, statNameThread2, "us"));
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2Loop, statNameThread2Loop, "us"));
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3, statNameThread3, "us"));
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3Loop, statNameThread3Loop, "us"));
-
-        //Let's kickoff the threads to see how much contention affects the profiler's performance.
-        const int iter_count = 1000000;
-        AZStd::thread t1(AZStd::bind(&simple_thread01, &profiler, iter_count));
-        AZStd::thread t2(AZStd::bind(&simple_thread02, &profiler, iter_count));
-        AZStd::thread t3(AZStd::bind(&simple_thread03, &profiler, iter_count));
-        t1.join();
-        t2.join();
-        t3.join();
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread1) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread1)->GetNumSamples(), 1);
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread1Loop) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread1Loop)->GetNumSamples(), iter_count);
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread2) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread2)->GetNumSamples(), 1);
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread2Loop) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread2Loop)->GetNumSamples(), iter_count);
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread3) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread3)->GetNumSamples(), 1);
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread3Loop) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread3Loop)->GetNumSamples(), iter_count);
-
-        profiler.LogAndResetStats("3_Threads_StatisticalProfiler");
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread1) != nullptr);
-
-    }
-
-#define CODE_PROFILER_PROXY_PUSH_TIME(profiler, scopeNameId) \
-    AZ::Statistics::StatisticalProfilerProxy::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
-
-    TEST_F(Suite_StatisticalProfilerPerformance, StatisticalProfilerProxy_1ThreadPerformance)
-    {
-        AZ::Statistics::StatisticalProfilerProxy::TimedScope::ClearCachedProxy();
-        AZ::Statistics::StatisticalProfilerProxy profilerProxy;
-        AZ::Statistics::StatisticalProfilerProxy* proxy = AZ::Interface<AZ::Statistics::StatisticalProfilerProxy>::Get();
-        AZ::Statistics::StatisticalProfilerProxy::StatisticalProfilerType& profiler = proxy->GetProfiler(Terrain);
-
-        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdPerformance = "PerformanceResult";
-        const AZStd::string statNamePerformance("PerformanceResult");
-
-        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdBlock = "Block";
-        const AZStd::string statNameBlock("Block");
-
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdPerformance, statNamePerformance, "us") != nullptr);
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdBlock, statNameBlock, "us") != nullptr);
-
-        proxy->ActivateProfiler(Terrain, true);
-
-        const int iter_count = 1000000;
-        {
-            CODE_PROFILER_PROXY_PUSH_TIME(Terrain, statIdPerformance)
-                int counter = 0;
-            for (int i = 0; i < iter_count; i++)
-            {
-                CODE_PROFILER_PROXY_PUSH_TIME(Terrain, statIdBlock)
-                    counter++;
-            }
-        }
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdPerformance)->GetNumSamples(), 1);
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdBlock) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdBlock)->GetNumSamples(), iter_count);
-
-        profiler.LogAndResetStats("StatisticalProfilerProxy");
-
-        //Clean Up
-        proxy->ActivateProfiler(Terrain, false);
-    }
-
-#undef CODE_PROFILER_PROXY_PUSH_TIME
-
-    TEST_F(Suite_StatisticalProfilerPerformance, StatisticalProfilerProxy_3ThreadsPerformance)
-    {
-        AZ::Statistics::StatisticalProfilerProxy::TimedScope::ClearCachedProxy();
-        AZ::Statistics::StatisticalProfilerProxy profilerProxy;
-        AZ::Statistics::StatisticalProfilerProxy* proxy = AZ::Interface<AZ::Statistics::StatisticalProfilerProxy>::Get();
-        AZ::Statistics::StatisticalProfilerProxy::StatisticalProfilerType& profiler = proxy->GetProfiler(Terrain);
-
-        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread1 = "simple_thread1";
-        const AZStd::string statNameThread1("simple_thread1");
-        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread1Loop = "simple_thread1_loop";
-        const AZStd::string statNameThread1Loop("simple_thread1_loop");
-
-        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread2 = "simple_thread2";
-        const AZStd::string statNameThread2("simple_thread2");
-        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread2Loop = "simple_thread2_loop";
-        const AZStd::string statNameThread2Loop("simple_thread2_loop");
-
-        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread3 = "simple_thread3";
-        const AZStd::string statNameThread3("simple_thread3");
-        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread3Loop = "simple_thread3_loop";
-        const AZStd::string statNameThread3Loop("simple_thread3_loop");
-
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1, statNameThread1, "us"));
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1Loop, statNameThread1Loop, "us"));
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2, statNameThread2, "us"));
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2Loop, statNameThread2Loop, "us"));
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3, statNameThread3, "us"));
-        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3Loop, statNameThread3Loop, "us"));
-
-        proxy->ActivateProfiler(Terrain, true);
-
-        //Let's kickoff the threads to see how much contention affects the profiler's performance.
-        const int iter_count = 1000000;
-        AZStd::thread t1(AZStd::bind(&simple_thread1, iter_count));
-        AZStd::thread t2(AZStd::bind(&simple_thread2, iter_count));
-        AZStd::thread t3(AZStd::bind(&simple_thread3, iter_count));
-        t1.join();
-        t2.join();
-        t3.join();
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread1) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread1)->GetNumSamples(), 1);
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread1Loop) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread1Loop)->GetNumSamples(), iter_count);
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread2) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread2)->GetNumSamples(), 1);
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread2Loop) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread2Loop)->GetNumSamples(), iter_count);
-
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread3) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread3)->GetNumSamples(), 1);
-        ASSERT_TRUE(profiler.GetStatistic(statIdThread3Loop) != nullptr);
-        EXPECT_EQ(profiler.GetStatistic(statIdThread3Loop)->GetNumSamples(), iter_count);
-
-        profiler.LogAndResetStats("3_Threads_StatisticalProfilerProxy");
-
-        //Clean Up
-        proxy->ActivateProfiler(Terrain, false);
-    }
-
-}//namespace UnitTest
diff --git a/Code/Framework/AzCore/Tests/Statistics.cpp b/Code/Framework/AzCore/Tests/Statistics.cpp
deleted file mode 100644
index 941c2eff0b..0000000000
--- a/Code/Framework/AzCore/Tests/Statistics.cpp
+++ /dev/null
@@ -1,263 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#include <AzCore/UnitTest/TestTypes.h>
-#include <AzCore/UnitTest/UnitTest.h>
-#include <AzTest/AzTest.h>
-
-#include <AzCore/Math/Crc.h>
-#include <AzCore/std/string/string.h>
-
-#include <AzCore/Statistics/StatisticsManager.h>
-
-using namespace AZ;
-using namespace Debug;
-
-namespace UnitTest
-{
-    class StatisticsTest
-        : public AllocatorsFixture
-    {
-    public:
-        StatisticsTest()
-        {
-        }
-
-        void SetUp() override
-        {
-            AllocatorsFixture::SetUp();
-
-            m_dataSamples = AZStd::make_unique<AZStd::vector<u32>>();
-            const u32 numSamples = 100;
-            m_dataSamples->set_capacity(numSamples);
-            for (u32 i = 0; i < numSamples; ++i)
-            {
-                m_dataSamples->push_back(i);
-            }
-        }
-
-        ~StatisticsTest()
-        {
-        }
-
-        void TearDown() override
-        {
-            // clearing up memory
-            m_dataSamples = nullptr;
-
-            AllocatorsFixture::TearDown();
-        }
-
-    protected:
-        AZStd::unique_ptr<AZStd::vector<u32>> m_dataSamples;
-    }; //class StatisticsTest
-
-    TEST_F(StatisticsTest, RunningStatistic_ProcessAnArrayOfNumbers_GetExpectedStatisticalData)
-    {
-        Statistics::RunningStatistic runningStat;
-
-        ASSERT_TRUE(m_dataSamples.get() != nullptr);
-        const AZStd::vector<u32>& dataSamples = *m_dataSamples;
-        for (u32 sample : dataSamples)
-        {
-            runningStat.PushSample(sample);
-        }
-
-        EXPECT_EQ(runningStat.GetNumSamples(), dataSamples.size());
-        EXPECT_EQ(runningStat.GetMostRecentSample(), dataSamples.back());
-        EXPECT_EQ(runningStat.GetMinimum(), dataSamples[0]);
-        EXPECT_EQ(runningStat.GetMaximum(), dataSamples.back());
-        EXPECT_NEAR(runningStat.GetAverage(), 49.5, 0.001);
-        EXPECT_NEAR(runningStat.GetVariance(), 841.666, 0.001);
-        EXPECT_NEAR(runningStat.GetStdev(), 29.011, 0.001);
-        EXPECT_NEAR(runningStat.GetVariance(Statistics::VarianceType::P), 833.25, 0.001);
-        EXPECT_NEAR(runningStat.GetStdev(Statistics::VarianceType::P), 28.866, 0.001);
-
-        //Reset the stat object.
-        runningStat.Reset();
-        EXPECT_EQ(runningStat.GetNumSamples(), 0);
-        EXPECT_EQ(runningStat.GetAverage(), 0.0);
-        EXPECT_EQ(runningStat.GetStdev(), 0.0);
-    }
-
-
-    TEST_F(StatisticsTest, StatisticsManager_AddAndRemoveStatisticistics_CollectionIntegrityIsCorrect)
-    {
-        Statistics::StatisticsManager<> statsManager;
-        AZStd::string statName0("stat0");
-        AZStd::string statName1("stat1");
-        AZStd::string statName2("stat2");
-        AZStd::string statName3("stat3");
-        EXPECT_TRUE(statsManager.AddStatistic(statName0, statName0, ""));
-        EXPECT_TRUE(statsManager.AddStatistic(statName1, statName1, ""));
-        EXPECT_TRUE(statsManager.AddStatistic(statName2, statName2, ""));
-        EXPECT_TRUE(statsManager.AddStatistic(statName3, statName3, ""));
-
-        //Validate the number of running statistics object we have so far.
-        {
-            AZStd::vector<Statistics::NamedRunningStatistic*> allStats;
-            statsManager.GetAllStatistics(allStats);
-            EXPECT_TRUE(allStats.size() == 4);
-        }
-
-        //Try to add an Stat that already exist. expect to fail.
-        EXPECT_EQ(statsManager.AddStatistic(statName1), nullptr);
-
-        //Remove stat1.
-        statsManager.RemoveStatistic(statName1);
-        //Validate the number of running statistics object we have so far.
-        {
-            AZStd::vector<Statistics::NamedRunningStatistic*> allStats;
-            statsManager.GetAllStatistics(allStats);
-            EXPECT_TRUE(allStats.size() == 3);
-        }
-
-        //Add stat1 again, expect to pass.
-        EXPECT_TRUE(statsManager.AddStatistic(statName1));
-
-        //Get a pointer to stat2.
-        Statistics::NamedRunningStatistic* stat2 = statsManager.GetStatistic(statName2);
-        ASSERT_TRUE(stat2 != nullptr);
-        EXPECT_EQ(stat2->GetName(), statName2);
-    }
-
-    TEST_F(StatisticsTest, StatisticsManager_DistributeSamplesAcrossStatistics_StatisticsAreCorrect)
-    {
-        Statistics::StatisticsManager<> statsManager;
-        AZStd::string statName0("stat0");
-        AZStd::string statName1("stat1");
-        AZStd::string statName2("stat2");
-        AZStd::string statName3("stat3");
-
-        EXPECT_TRUE(statsManager.AddStatistic(statName3));
-        EXPECT_TRUE(statsManager.AddStatistic(statName0));
-        EXPECT_TRUE(statsManager.AddStatistic(statName2));
-        EXPECT_TRUE(statsManager.AddStatistic(statName1));
-
-        //Distribute the 100 samples of data evenly across the 4 running statistics.
-        ASSERT_TRUE(m_dataSamples.get() != nullptr);
-        const AZStd::vector<u32>& dataSamples = *m_dataSamples;
-        const size_t numSamples = dataSamples.size();
-        const size_t numSamplesPerStat = numSamples / 4;
-        size_t sampleIndex = 0;
-        size_t nextStopIndex = numSamplesPerStat;
-        while (sampleIndex < nextStopIndex)
-        {
-            statsManager.PushSampleForStatistic(statName0, dataSamples[sampleIndex]);
-            sampleIndex++;
-        }
-        nextStopIndex += numSamplesPerStat;
-        while (sampleIndex < nextStopIndex)
-        {
-            statsManager.PushSampleForStatistic(statName1, dataSamples[sampleIndex]);
-            sampleIndex++;
-        }
-        nextStopIndex += numSamplesPerStat;
-        while (sampleIndex < nextStopIndex)
-        {
-            statsManager.PushSampleForStatistic(statName2, dataSamples[sampleIndex]);
-            sampleIndex++;
-        }
-        nextStopIndex += numSamplesPerStat;
-        while (sampleIndex < nextStopIndex)
-        {
-            statsManager.PushSampleForStatistic(statName3, dataSamples[sampleIndex]);
-            sampleIndex++;
-        }
-
-        EXPECT_NEAR(statsManager.GetStatistic(statName0)->GetAverage(), 12.0, 0.001);
-        EXPECT_NEAR(statsManager.GetStatistic(statName1)->GetAverage(), 37.0, 0.001);
-        EXPECT_NEAR(statsManager.GetStatistic(statName2)->GetAverage(), 62.0, 0.001);
-        EXPECT_NEAR(statsManager.GetStatistic(statName3)->GetAverage(), 87.0, 0.001);
-
-        EXPECT_NEAR(statsManager.GetStatistic(statName0)->GetStdev(), 7.359, 0.001);
-        EXPECT_NEAR(statsManager.GetStatistic(statName1)->GetStdev(), 7.359, 0.001);
-        EXPECT_NEAR(statsManager.GetStatistic(statName2)->GetStdev(), 7.359, 0.001);
-        EXPECT_NEAR(statsManager.GetStatistic(statName3)->GetStdev(), 7.359, 0.001);
-
-        //Reset one of the stats.
-        statsManager.ResetStatistic(statName2);
-        EXPECT_EQ(statsManager.GetStatistic(statName2)->GetAverage(), 0.0);
-        //Reset all of the stats.
-        statsManager.ResetAllStatistics();
-        EXPECT_EQ(statsManager.GetStatistic(statName0)->GetNumSamples(), 0);
-        EXPECT_EQ(statsManager.GetStatistic(statName1)->GetNumSamples(), 0);
-        EXPECT_EQ(statsManager.GetStatistic(statName2)->GetNumSamples(), 0);
-        EXPECT_EQ(statsManager.GetStatistic(statName3)->GetNumSamples(), 0);
-    }
-
-    TEST_F(StatisticsTest, StatisticsManagerCrc32_DistributeSamplesAcrossStatistics_StatisticsAreCorrect)
-    {
-        Statistics::StatisticsManager<AZ::Crc32> statsManager;
-        AZ::Crc32 statName0 = AZ_CRC("stat0", 0xb8927780);
-        AZ::Crc32 statName1 = AZ_CRC("stat1", 0xcf954716);
-        AZ::Crc32 statName2 = AZ_CRC("stat2", 0x569c16ac);
-        AZ::Crc32 statName3 = AZ_CRC("stat3", 0x219b263a);
-
-        EXPECT_TRUE(statsManager.AddStatistic(statName3) != nullptr);
-        EXPECT_TRUE(statsManager.AddStatistic(statName0) != nullptr);
-        EXPECT_TRUE(statsManager.AddStatistic(statName2) != nullptr);
-        EXPECT_TRUE(statsManager.AddStatistic(statName1) != nullptr);
-
-        EXPECT_TRUE(statsManager.GetStatistic(statName3) != nullptr);
-        EXPECT_TRUE(statsManager.GetStatistic(statName0) != nullptr);
-        EXPECT_TRUE(statsManager.GetStatistic(statName1) != nullptr);
-        EXPECT_TRUE(statsManager.GetStatistic(statName2) != nullptr);
-
-        //Distribute the 100 samples of data evenly across the 4 running statistics.
-        ASSERT_TRUE(m_dataSamples.get() != nullptr);
-        const AZStd::vector<u32>& dataSamples = *m_dataSamples;
-        const size_t numSamples = dataSamples.size();
-        const size_t numSamplesPerStat = numSamples / 4;
-        size_t sampleIndex = 0;
-        size_t nextStopIndex = numSamplesPerStat;
-        while (sampleIndex < nextStopIndex)
-        {
-            statsManager.PushSampleForStatistic(statName0, dataSamples[sampleIndex]);
-            sampleIndex++;
-        }
-        nextStopIndex += numSamplesPerStat;
-        while (sampleIndex < nextStopIndex)
-        {
-            statsManager.PushSampleForStatistic(statName1, dataSamples[sampleIndex]);
-            sampleIndex++;
-        }
-        nextStopIndex += numSamplesPerStat;
-        while (sampleIndex < nextStopIndex)
-        {
-            statsManager.PushSampleForStatistic(statName2, dataSamples[sampleIndex]);
-            sampleIndex++;
-        }
-        nextStopIndex += numSamplesPerStat;
-        while (sampleIndex < nextStopIndex)
-        {
-            statsManager.PushSampleForStatistic(statName3, dataSamples[sampleIndex]);
-            sampleIndex++;
-        }
-
-        EXPECT_NEAR(statsManager.GetStatistic(statName0)->GetAverage(), 12.0, 0.001);
-        EXPECT_NEAR(statsManager.GetStatistic(statName1)->GetAverage(), 37.0, 0.001);
-        EXPECT_NEAR(statsManager.GetStatistic(statName2)->GetAverage(), 62.0, 0.001);
-        EXPECT_NEAR(statsManager.GetStatistic(statName3)->GetAverage(), 87.0, 0.001);
-
-        EXPECT_NEAR(statsManager.GetStatistic(statName0)->GetStdev(), 7.359, 0.001);
-        EXPECT_NEAR(statsManager.GetStatistic(statName1)->GetStdev(), 7.359, 0.001);
-        EXPECT_NEAR(statsManager.GetStatistic(statName2)->GetStdev(), 7.359, 0.001);
-        EXPECT_NEAR(statsManager.GetStatistic(statName3)->GetStdev(), 7.359, 0.001);
-
-        //Reset one of the stats.
-        statsManager.ResetStatistic(statName2);
-        EXPECT_EQ(statsManager.GetStatistic(statName2)->GetAverage(), 0.0);
-        //Reset all of the stats.
-        statsManager.ResetAllStatistics();
-        EXPECT_EQ(statsManager.GetStatistic(statName0)->GetNumSamples(), 0);
-        EXPECT_EQ(statsManager.GetStatistic(statName1)->GetNumSamples(), 0);
-        EXPECT_EQ(statsManager.GetStatistic(statName2)->GetNumSamples(), 0);
-        EXPECT_EQ(statsManager.GetStatistic(statName3)->GetNumSamples(), 0);
-    }
-
-}//namespace UnitTest
diff --git a/Code/Framework/AzCore/Tests/TimeDataStatistics.cpp b/Code/Framework/AzCore/Tests/TimeDataStatistics.cpp
deleted file mode 100644
index 192d9dc7f6..0000000000
--- a/Code/Framework/AzCore/Tests/TimeDataStatistics.cpp
+++ /dev/null
@@ -1,207 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#include <AzCore/UnitTest/TestTypes.h>
-#include <AzCore/UnitTest/UnitTest.h>
-#include <AzTest/AzTest.h>
-
-#include <AzCore/std/string/string.h>
-#include <AzCore/std/parallel/thread.h>
-
-#include <AzCore/Statistics/TimeDataStatisticsManager.h>
-
-#include <AzCore/Component/Component.h>
-#include <AzCore/Component/ComponentApplication.h>
-#include <AzCore/Component/TickBus.h>
-#include <AzCore/Component/EntityUtils.h>
-#include <AzCore/Debug/FrameProfilerBus.h>
-#include <AzCore/Debug/FrameProfilerComponent.h>
-
-using namespace AZ;
-using namespace Debug;
-
-namespace UnitTest
-{
-    /**
-     * Validate functionality of the convenience class TimeDataStatisticsManager.
-     * It is a specialized version of RunningStatisticsManager that works with Timer type
-     * of registers that can be captured with the FrameProfilerBus::OnFrameProfilerData()
-     */
-    class TimeDataStatisticsManagerTest
-        : public AllocatorsFixture
-        , public FrameProfilerBus::Handler
-    {
-        static constexpr const char* PARENT_TIMER_STAT = "ParentStat";
-        static constexpr const char* CHILD_TIMER_STAT0 = "ChildStat0";
-        static constexpr const char* CHILD_TIMER_STAT1 = "ChildStat1";
-
-    public:
-        TimeDataStatisticsManagerTest()
-            : AllocatorsFixture()
-        {
-        }
-
-        void SetUp() override
-        {
-            AllocatorsFixture::SetUp();
-            m_statsManager = AZStd::make_unique<Statistics::TimeDataStatisticsManager>();
-        }
-
-        void TearDown() override
-        {
-            m_statsManager = nullptr;
-            AllocatorsFixture::TearDown();
-        }
-
-        //////////////////////////////////////////////////////////////////////////
-        // FrameProfilerBus
-        virtual void OnFrameProfilerData(const FrameProfiler::ThreadDataArray& data)
-        {
-            for (size_t iThread = 0; iThread < data.size(); ++iThread)
-            {
-                const FrameProfiler::ThreadData& td = data[iThread];
-                FrameProfiler::ThreadData::RegistersMap::const_iterator regIt = td.m_registers.begin();
-                for (; regIt != td.m_registers.end(); ++regIt)
-                {
-                    const FrameProfiler::RegisterData& rd = regIt->second;
-                    u32 unitTestCrc = AZ_CRC("UnitTest", 0x8089cea8);
-                    if (unitTestCrc != rd.m_systemId)
-                    {
-                        continue; //Not for us.
-                    }
-                    ASSERT_EQ(ProfilerRegister::PRT_TIME, rd.m_type);
-                    const FrameProfiler::FrameData& fd = rd.m_frames.back();
-                    m_statsManager->PushTimeDataSample(rd.m_name, fd.m_timeData);
-                }
-            }
-        }
-        //////////////////////////////////////////////////////////////////////////
-
-        int ChildFunction0(int numIterations, int sleepTimeMilliseconds)
-        {
-            AZ_PROFILE_SCOPE(AzCore, CHILD_TIMER_STAT0);
-            AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(sleepTimeMilliseconds));
-            int result = 5;
-            for (int i = 0; i < numIterations; ++i)
-            {
-                result += i % 3;
-            }
-            return result;
-        }
-
-        int ChildFunction1(int numIterations, int sleepTimeMilliseconds)
-        {
-            AZ_PROFILE_SCOPE(AzCore, CHILD_TIMER_STAT1);
-            AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(sleepTimeMilliseconds));
-            int result = 5;
-            for (int i = 0; i < numIterations; ++i)
-            {
-                result += i % 3;
-            }
-            return result;
-        }
-
-        int ParentFunction(int numIterations, int sleepTimeMilliseconds)
-        {
-            AZ_PROFILE_SCOPE(AzCore, PARENT_TIMER_STAT);
-            AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(sleepTimeMilliseconds));
-            int result = 0;
-            result += ChildFunction0(numIterations, sleepTimeMilliseconds);
-            result += ChildFunction1(numIterations, sleepTimeMilliseconds);
-            return result;
-        }
-
-        void run()
-        {
-           Debug::FrameProfilerBus::Handler::BusConnect();
-           
-           ComponentApplication app;
-           ComponentApplication::Descriptor desc;
-           desc.m_useExistingAllocator = true;
-           desc.m_enableDrilling = false;  // we already created a memory driller for the test (AllocatorsFixture)
-           ComponentApplication::StartupParameters startupParams;
-           startupParams.m_allocator = &AllocatorInstance<SystemAllocator>::Get();
-           Entity* systemEntity = app.Create(desc, startupParams);
-           systemEntity->CreateComponent<FrameProfilerComponent>();
-           
-           systemEntity->Init();
-           systemEntity->Activate(); // start frame component
-           
-           const int sleepTimeAllFuncsMillis = 1;
-           const int numIterations = 10;
-           for (int iterationCounter = 0; iterationCounter < numIterations; ++iterationCounter)
-           {
-               ParentFunction(numIterations, sleepTimeAllFuncsMillis);
-               //Collect all samples.
-               app.Tick();
-           }
-
-           //Verify we have three running stats.
-           {
-               AZStd::vector<Statistics::NamedRunningStatistic*> allStats;
-               m_statsManager->GetAllStatistics(allStats);
-               EXPECT_EQ(allStats.size(), 3);
-           }
-
-           AZStd::string parentStatName(PARENT_TIMER_STAT);
-           AZStd::string child0StatName(CHILD_TIMER_STAT0);
-           AZStd::string child1StatName(CHILD_TIMER_STAT1);
-           ASSERT_TRUE(m_statsManager->GetStatistic(parentStatName) != nullptr);
-           ASSERT_TRUE(m_statsManager->GetStatistic(child0StatName) != nullptr);
-           ASSERT_TRUE(m_statsManager->GetStatistic(child1StatName) != nullptr);
-           
-           EXPECT_EQ(m_statsManager->GetStatistic(parentStatName)->GetNumSamples(), numIterations);
-           EXPECT_EQ(m_statsManager->GetStatistic(child0StatName)->GetNumSamples(), numIterations);
-           EXPECT_EQ(m_statsManager->GetStatistic(child1StatName)->GetNumSamples(), numIterations);
-
-           const double minimumExpectDurationOfChildFunctionMicros = 1;
-           const double minimumExpectDurationOfParentFunctionMicros = 1;
-
-           EXPECT_GE(m_statsManager->GetStatistic(parentStatName)->GetMinimum(), minimumExpectDurationOfParentFunctionMicros);
-           EXPECT_GE(m_statsManager->GetStatistic(parentStatName)->GetAverage(), minimumExpectDurationOfParentFunctionMicros);
-           EXPECT_GE(m_statsManager->GetStatistic(parentStatName)->GetMaximum(), minimumExpectDurationOfParentFunctionMicros);
-
-           EXPECT_GE(m_statsManager->GetStatistic(child0StatName)->GetMinimum(), minimumExpectDurationOfChildFunctionMicros);
-           EXPECT_GE(m_statsManager->GetStatistic(child0StatName)->GetAverage(), minimumExpectDurationOfChildFunctionMicros);
-           EXPECT_GE(m_statsManager->GetStatistic(child0StatName)->GetMaximum(), minimumExpectDurationOfChildFunctionMicros);
-                                                                                                                      
-           EXPECT_GE(m_statsManager->GetStatistic(child1StatName)->GetMinimum(), minimumExpectDurationOfChildFunctionMicros);
-           EXPECT_GE(m_statsManager->GetStatistic(child1StatName)->GetAverage(), minimumExpectDurationOfChildFunctionMicros);
-           EXPECT_GE(m_statsManager->GetStatistic(child1StatName)->GetMaximum(), minimumExpectDurationOfChildFunctionMicros);
-
-           //Let's validate TimeDataStatisticsManager::RemoveStatistics()
-           m_statsManager->RemoveStatistic(child1StatName);
-           ASSERT_TRUE(m_statsManager->GetStatistic(parentStatName) != nullptr);
-           ASSERT_TRUE(m_statsManager->GetStatistic(child0StatName) != nullptr);
-           EXPECT_EQ(m_statsManager->GetStatistic(child1StatName), nullptr);
-
-           //Let's store the sample count for both parentStatName and child0StatName.
-           const AZ::u64 numSamplesParent = m_statsManager->GetStatistic(parentStatName)->GetNumSamples();
-           const AZ::u64 numSamplesChild0 = m_statsManager->GetStatistic(child0StatName)->GetNumSamples();
-
-           //Let's call child1 function again and call app.Tick(). child1StatName should be readded to m_statsManager.
-           ChildFunction1(numIterations, sleepTimeAllFuncsMillis);
-           app.Tick();
-           ASSERT_TRUE(m_statsManager->GetStatistic(child1StatName) != nullptr);
-           EXPECT_EQ(m_statsManager->GetStatistic(parentStatName)->GetNumSamples(), numSamplesParent);
-           EXPECT_EQ(m_statsManager->GetStatistic(child0StatName)->GetNumSamples(), numSamplesChild0);
-           EXPECT_EQ(m_statsManager->GetStatistic(child1StatName)->GetNumSamples(), 1);
-
-           Debug::FrameProfilerBus::Handler::BusDisconnect();
-           app.Destroy();
-        }
-
-        AZStd::unique_ptr<Statistics::TimeDataStatisticsManager> m_statsManager;
-    };//class TimeDataStatisticsManagerTest
-
-    TEST_F(TimeDataStatisticsManagerTest, Test)
-    {
-        run();
-    }
-    //End of all Tests of TimeDataStatisticsManagerTest
-
-}//namespace UnitTest
diff --git a/Code/Framework/AzCore/Tests/azcoretests_files.cmake b/Code/Framework/AzCore/Tests/azcoretests_files.cmake
index 911eaa7b10..7833cf97bb 100644
--- a/Code/Framework/AzCore/Tests/azcoretests_files.cmake
+++ b/Code/Framework/AzCore/Tests/azcoretests_files.cmake
@@ -60,13 +60,11 @@ set(FILES
     SerializeContextFixture.h
     Slice.cpp
     State.cpp
-    Statistics.cpp
     StreamerTests.cpp
     StringFunc.cpp
     SystemFile.cpp
     TaskTests.cpp
     TickBusTest.cpp
-    TimeDataStatistics.cpp
     UUIDTests.cpp
     XML.cpp
     Debug/AssetTracking.cpp
diff --git a/Code/Framework/AzFramework/CMakeLists.txt b/Code/Framework/AzFramework/CMakeLists.txt
index 8a68aac887..2748da20dc 100644
--- a/Code/Framework/AzFramework/CMakeLists.txt
+++ b/Code/Framework/AzFramework/CMakeLists.txt
@@ -10,7 +10,6 @@
 ly_get_list_relative_pal_filename(pal_dir ${CMAKE_CURRENT_LIST_DIR}/Platform/${PAL_PLATFORM_NAME})
 ly_get_list_relative_pal_filename(common_dir ${CMAKE_CURRENT_LIST_DIR}/Platform/Common)
 
-set(LY_STATISTICAL_PROFILING_ENABLED OFF CACHE BOOL "Enables statistical profiling when using AZ_PROFILE_SCOPE. If True, it takes effect only if RAD Telemetry is disabled.")
 set(LY_TOUCHBENDING_LAYER_BIT 63 CACHE STRING "Use TouchBending as the collision layer. The TouchBending layer can be a number from 1 to 63 (Default=63).")
 
 ly_add_target(
@@ -38,14 +37,6 @@ ly_add_target(
             3rdParty::lz4
 )
 
-if(LY_STATISTICAL_PROFILING_ENABLED)
-    ly_add_source_properties(
-        SOURCES AzFramework/Debug/StatisticalProfilerProxy.h
-        PROPERTY COMPILE_DEFINITIONS 
-        VALUES AZ_STATISTICAL_PROFILING_ENABLED
-    )
-endif()
-
 ly_add_source_properties(
     SOURCES 
         AzFramework/Physics/Collision/CollisionGroups.cpp
diff --git a/Code/Framework/GridMate/GridMate/Replica/ReplicaMgr.cpp b/Code/Framework/GridMate/GridMate/Replica/ReplicaMgr.cpp
index f1b91fa1ad..2582710aa7 100644
--- a/Code/Framework/GridMate/GridMate/Replica/ReplicaMgr.cpp
+++ b/Code/Framework/GridMate/GridMate/Replica/ReplicaMgr.cpp
@@ -700,7 +700,7 @@ namespace GridMate
     {
         if (IsUsingFixedTimeStep())
         {
-            return static_cast<AZ::u32>(m_fixedTimeStep.CurrentTime());
+            return static_cast<AZ::u32>(m_fixedTimeStep.GetCurrentTime());
         }
         else
         {
diff --git a/Code/Framework/GridMate/GridMate/Replica/ReplicaMgr.h b/Code/Framework/GridMate/GridMate/Replica/ReplicaMgr.h
index bedff54939..bd9f1a1ee9 100644
--- a/Code/Framework/GridMate/GridMate/Replica/ReplicaMgr.h
+++ b/Code/Framework/GridMate/GridMate/Replica/ReplicaMgr.h
@@ -302,7 +302,7 @@ namespace GridMate
             // this could allow for changing on the fly but it would need to ensure that if it were in the middle of a second, that the new rate would result in landing on the
         }
 
-        AZ::u64 CurrentTime() const
+        AZ::u64 GetCurrentTime() const
         {
             return m_currentTime;
         }
diff --git a/Gems/Atom/Asset/ImageProcessingAtom/Code/Include/Atom/ImageProcessing/ImageProcessingBus.h b/Gems/Atom/Asset/ImageProcessingAtom/Code/Include/Atom/ImageProcessing/ImageProcessingBus.h
index fc89abfc9a..cb6c742722 100644
--- a/Gems/Atom/Asset/ImageProcessingAtom/Code/Include/Atom/ImageProcessing/ImageProcessingBus.h
+++ b/Gems/Atom/Asset/ImageProcessingAtom/Code/Include/Atom/ImageProcessing/ImageProcessingBus.h
@@ -73,4 +73,3 @@ namespace ImageProcessingAtom
 
     using ImageBuilderRequestBus = AZ::EBus<ImageBuilderRequests>;
 } // namespace ImageProcessingAtom
-
diff --git a/Gems/Atom/Feature/Common/Code/Source/Decals/DecalTextureArrayFeatureProcessor.cpp b/Gems/Atom/Feature/Common/Code/Source/Decals/DecalTextureArrayFeatureProcessor.cpp
index 90fd926b99..10dab85dcb 100644
--- a/Gems/Atom/Feature/Common/Code/Source/Decals/DecalTextureArrayFeatureProcessor.cpp
+++ b/Gems/Atom/Feature/Common/Code/Source/Decals/DecalTextureArrayFeatureProcessor.cpp
@@ -295,7 +295,7 @@ namespace AZ
 
         void DecalTextureArrayFeatureProcessor::SetDecalMaterial(const DecalHandle handle, const AZ::Data::AssetId material)
         {
-            AZ_PROFILE_FUNCTION(Renderer);
+            AZ_PROFILE_FUNCTION(AzRender);
             if (handle.IsNull())
             {
                 AZ_Warning("DecalTextureArrayFeatureProcessor", false, "Invalid handle passed to DecalTextureArrayFeatureProcessor::SetDecalMaterial().");
@@ -365,7 +365,7 @@ namespace AZ
 
         void DecalTextureArrayFeatureProcessor::OnAssetReady(const Data::Asset<Data::AssetData> asset)
         {
-            AZ_PROFILE_FUNCTION(Renderer);
+            AZ_PROFILE_FUNCTION(AzRender);
             const Data::AssetId& assetId = asset->GetId();
             
             const RPI::MaterialAsset* materialAsset = asset.GetAs<AZ::RPI::MaterialAsset>();
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Public/Scene.cpp b/Gems/Atom/RPI/Code/Source/RPI.Public/Scene.cpp
index 4d3dcba36e..26fdae1c54 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Public/Scene.cpp
+++ b/Gems/Atom/RPI/Code/Source/RPI.Public/Scene.cpp
@@ -21,6 +21,7 @@
 #include <Atom/RPI.Public/View.h>
 
 #include <AzCore/Debug/EventTrace.h>
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/Jobs/JobFunction.h>
 #include <AzCore/Jobs/JobEmpty.h>
 
@@ -541,6 +542,7 @@ namespace AZ
                     {
                         view->FinalizeDrawLists();
                     }
+                    AZ_PROFILE_END();
                 }
                 else
                 {
diff --git a/Gems/EMotionFX/Code/EMotionFX/Source/MotionInstance.h b/Gems/EMotionFX/Code/EMotionFX/Source/MotionInstance.h
index f41cf29c79..8ca1ab570f 100644
--- a/Gems/EMotionFX/Code/EMotionFX/Source/MotionInstance.h
+++ b/Gems/EMotionFX/Code/EMotionFX/Source/MotionInstance.h
@@ -20,6 +20,9 @@
 #include <EMotionFX/Source/EventInfo.h>
 #include <EMotionFX/Source/MotionInstancePool.h>
 
+#if defined GetCurrentTime
+#undef GetCurrentTime
+#endif
 
 namespace EMotionFX
 {
diff --git a/Gems/MultiplayerCompression/Code/Tests/MultiplayerCompressionTest.cpp b/Gems/MultiplayerCompression/Code/Tests/MultiplayerCompressionTest.cpp
index 5a3304fecd..d9daced995 100644
--- a/Gems/MultiplayerCompression/Code/Tests/MultiplayerCompressionTest.cpp
+++ b/Gems/MultiplayerCompression/Code/Tests/MultiplayerCompressionTest.cpp
@@ -12,7 +12,7 @@
 #include <LZ4Compressor.h>
 
 #include <AzCore/Compression/Compression.h>
-#include <AzCore/std/time.h>
+#include <AzCore/std/chrono/clocks.h>
 #include <AzNetworking/DataStructures/ByteBuffer.h>
 #include <AzNetworking/Serialization/NetworkInputSerializer.h>
 #include <AzTest/AzTest.h>
diff --git a/Gems/NvCloth/Code/Source/System/SystemComponent.cpp b/Gems/NvCloth/Code/Source/System/SystemComponent.cpp
index 02a57cea6f..77223ba566 100644
--- a/Gems/NvCloth/Code/Source/System/SystemComponent.cpp
+++ b/Gems/NvCloth/Code/Source/System/SystemComponent.cpp
@@ -116,7 +116,7 @@ namespace NvCloth
             }
 
             void zoneEnd([[maybe_unused]] void* profilerData,
-                const char* eventName, bool detached,
+                [[maybe_unused]] const char* eventName, bool detached,
                 [[maybe_unused]] uint64_t contextId) override
             {
                 if (detached)
diff --git a/Gems/ScriptCanvas/Code/Editor/Nodes/NodeDisplayUtils.cpp b/Gems/ScriptCanvas/Code/Editor/Nodes/NodeDisplayUtils.cpp
index 65129e4054..b9e96938af 100644
--- a/Gems/ScriptCanvas/Code/Editor/Nodes/NodeDisplayUtils.cpp
+++ b/Gems/ScriptCanvas/Code/Editor/Nodes/NodeDisplayUtils.cpp
@@ -57,7 +57,7 @@ namespace ScriptCanvasEditor::Nodes
     // Handles the creation of a node through the node configurations for most nodes.
     AZ::EntityId DisplayGeneralScriptCanvasNode(AZ::EntityId, const ScriptCanvas::Node* node, const NodeConfiguration& nodeConfiguration)
     {
-        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
 
         AZ::Entity* graphCanvasEntity = nullptr;
 
@@ -445,7 +445,7 @@ namespace ScriptCanvasEditor::Nodes
 
     AZ::EntityId DisplayEbusEventNode(AZ::EntityId, const AZStd::string& busName, const AZStd::string& eventName, const ScriptCanvas::EBusEventId& eventId)
     {
-        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
 
         AZ::EntityId graphCanvasNodeId;
 
@@ -668,7 +668,7 @@ namespace ScriptCanvasEditor::Nodes
 
     AZ::EntityId DisplayScriptEventNode(AZ::EntityId, const AZ::Data::AssetId assetId, const ScriptEvents::Method& methodDefinition)
     {
-        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
 
         AZ::EntityId graphCanvasNodeId;
 
@@ -1001,7 +1001,7 @@ namespace ScriptCanvasEditor::Nodes
 
     AZ::EntityId DisplayGetVariableNode(AZ::EntityId graphCanvasGraphId, const ScriptCanvas::Nodes::Core::GetVariableNode* variableNode)
     {
-        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
 
         NodeConfiguration nodeConfiguration;
         nodeConfiguration.PopulateComponentDescriptors<IconComponent, DynamicSlotComponent, GetVariableNodeDescriptorComponent>();
@@ -1033,7 +1033,7 @@ namespace ScriptCanvasEditor::Nodes
 
     AZ::EntityId DisplaySetVariableNode(AZ::EntityId graphCanvasGraphId, const ScriptCanvas::Nodes::Core::SetVariableNode* variableNode)
     {
-        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
 
         NodeConfiguration nodeConfiguration;
         nodeConfiguration.PopulateComponentDescriptors<IconComponent, DynamicSlotComponent, SetVariableNodeDescriptorComponent>();
@@ -1069,7 +1069,7 @@ namespace ScriptCanvasEditor::Nodes
 ///////////////////
     AZ::EntityId DisplayScriptCanvasNode(AZ::EntityId graphCanvasGraphId, const ScriptCanvas::Node* node)
     {
-        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
         AZ::EntityId graphCanvasNodeId;
 
         if (azrtti_istypeof<ScriptCanvas::Nodes::Core::SetVariableNode>(node))
@@ -1122,7 +1122,7 @@ namespace ScriptCanvasEditor::Nodes
 
     static void RegisterAndActivateGraphCanvasSlot(AZ::EntityId graphCanvasNodeId, const ScriptCanvas::SlotId& slotId, AZ::Entity* slotEntity)
     {
-        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
         if (slotEntity)
         {
             slotEntity->Init();
@@ -1166,7 +1166,7 @@ namespace ScriptCanvasEditor::Nodes
             return AZ::EntityId();
         }
 
-        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
         AZ::Entity* slotEntity = nullptr;
 
         AZ::Uuid typeId = ScriptCanvas::Data::ToAZType(slot.GetDataType());
@@ -1258,7 +1258,7 @@ namespace ScriptCanvasEditor::Nodes::SlotDisplayHelper
 {
     AZ::EntityId DisplayPropertySlot(AZ::EntityId graphCanvasNodeId, const ScriptCanvas::VisualExtensionSlotConfiguration& propertyConfiguration)
     {
-        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
 
         GraphCanvas::SlotConfiguration graphCanvasConfiguration;
 
@@ -1284,7 +1284,7 @@ namespace ScriptCanvasEditor::Nodes::SlotDisplayHelper
 
     AZ::EntityId DisplayExtendableSlot(AZ::EntityId graphCanvasNodeId, const ScriptCanvas::VisualExtensionSlotConfiguration& extenderConfiguration)
     {
-        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
 
         GraphCanvas::ExtenderSlotConfiguration graphCanvasConfiguration;
 
diff --git a/cmake/3rdParty/FindPIX.cmake b/cmake/3rdParty/FindPIX.cmake
index 4bce14312d..e4652467ac 100644
--- a/cmake/3rdParty/FindPIX.cmake
+++ b/cmake/3rdParty/FindPIX.cmake
@@ -8,7 +8,7 @@
 
 if(LY_PIX_ENABLED)
     file(TO_CMAKE_PATH "${LY_PIX_PATH}" PIX_PATH)
-    message(STATUS "PIX PATH ${PIX_PATH}")
+    message(STATUS "PIX found: ${PIX_PATH}")
 
     ly_add_external_target(
         NAME pix
diff --git a/cmake/3rdParty/Platform/Windows/pix_windows.cmake b/cmake/3rdParty/Platform/Windows/pix_windows.cmake
index aba65d9627..54d419d1c2 100644
--- a/cmake/3rdParty/Platform/Windows/pix_windows.cmake
+++ b/cmake/3rdParty/Platform/Windows/pix_windows.cmake
@@ -11,4 +11,4 @@ if(LY_MONOLITHIC_GAME)
 else()
     set(PIX_LIBS ${BASE_PATH}/bin/x64/WinPixEventRuntime.lib)
     set(PIX_RUNTIME_DEPENDENCIES ${BASE_PATH}/bin/x64/WinPixEventRuntime.dll)
-endif()
\ No newline at end of file
+endif()

From 5f2fe83c5b99a058488fa3cb6c35b9d3ed728578 Mon Sep 17 00:00:00 2001
From: Jeremy Ong <jcong@amazon.com>
Date: Wed, 18 Aug 2021 09:16:44 -0600
Subject: [PATCH 29/37] Remove test associated with frame profiler going away

Signed-off-by: Jeremy Ong <jcong@amazon.com>
---
 Code/Framework/AzCore/Tests/Components.cpp | 147 ---------------------
 1 file changed, 147 deletions(-)

diff --git a/Code/Framework/AzCore/Tests/Components.cpp b/Code/Framework/AzCore/Tests/Components.cpp
index 37bb783642..77524dabc9 100644
--- a/Code/Framework/AzCore/Tests/Components.cpp
+++ b/Code/Framework/AzCore/Tests/Components.cpp
@@ -1191,153 +1191,6 @@ namespace UnitTest
         //////////////////////////////////////////////////////////////////////////
     }
 
-    class FrameProfilerComponentTest
-        : public AllocatorsFixture
-        , public FrameProfilerBus::Handler
-    {
-    public:
-        FrameProfilerComponentTest()
-            : AllocatorsFixture()
-        {
-        }
-
-        //////////////////////////////////////////////////////////////////////////
-        // FrameProfilerDrillerBus
-        void OnFrameProfilerData(const FrameProfiler::ThreadDataArray& data) override
-        {
-            for (size_t iThread = 0; iThread < data.size(); ++iThread)
-            {
-                const FrameProfiler::ThreadData& td = data[iThread];
-                FrameProfiler::ThreadData::RegistersMap::const_iterator regIt = td.m_registers.begin();
-                size_t numRegisters = m_numRegistersReceived;
-                for (; regIt != td.m_registers.end(); ++regIt)
-                {
-                    const FrameProfiler::RegisterData& rd = regIt->second;
-
-                    AZ_TEST_ASSERT(rd.m_function != NULL);
-                    if (strstr(rd.m_function, "ChildFunction") || strstr(rd.m_function, "Profile1")) // filter only the test registers
-                    {
-                        ++m_numRegistersReceived;
-
-                        EXPECT_GT(rd.m_line, 0);
-                        EXPECT_TRUE(rd.m_name == nullptr || strstr(rd.m_name, "Child1") || strstr(rd.m_name, "Custom name"));
-                        AZ::u32 unitTestCrc = AZ_CRC("UnitTest", 0x8089cea8);
-                        EXPECT_EQ(unitTestCrc, rd.m_systemId);
-                        EXPECT_EQ(ProfilerRegister::PRT_TIME, rd.m_type);
-
-                        EXPECT_FALSE(rd.m_frames.empty());
-                        const FrameProfiler::FrameData& fd = rd.m_frames.back();
-                        EXPECT_GT(fd.m_frameId, 0u);
-                        EXPECT_GT(fd.m_timeData.m_time, 0);
-                        EXPECT_GT(fd.m_timeData.m_calls, 0);
-                    }
-                }
-
-                if (numRegisters < m_numRegistersReceived)
-                {
-                    // we have received valid test registers for this thread, add it to the list
-                    ++m_numThreads;
-                }
-            }
-        }
-        //////////////////////////////////////////////////////////////////////////
-
-        int ChildFunction(int input)
-        {
-            AZ_PROFILE_FUNCTION(System);
-            int result = 5;
-            for (int i = 0; i < 10000; ++i)
-            {
-                result += i % (input + 3);
-            }
-            return result;
-        }
-
-        int ChildFunction1(int input)
-        {
-            AZ_PROFILE_SCOPE(AzCore, "Child1");
-            int result = 5;
-            for (int i = 0; i < 10000; ++i)
-            {
-                result += i % (input + 1);
-            }
-            return result;
-        }
-
-        int Profile1(int numIterations)
-        {
-            AZ_PROFILE_SCOPE(AzCore, "Custom name");
-            int result = 0;
-            for (int i = 0; i < numIterations; ++i)
-            {
-                result += ChildFunction(i);
-            }
-
-            result += ChildFunction1(numIterations / 3);
-            return result;
-        }
-
-        void run()
-        {
-            FrameProfilerBus::Handler::BusConnect();
-
-            ComponentApplication app;
-            ComponentApplication::Descriptor desc;
-            desc.m_useExistingAllocator = true;
-            desc.m_enableDrilling = false;  // we already created a memory driller for the test (AllocatorsFixture)
-            ComponentApplication::StartupParameters startupParams;
-            startupParams.m_allocator = &AZ::AllocatorInstance<AZ::SystemAllocator>::Get();
-            Entity* systemEntity = app.Create(desc, startupParams);
-            systemEntity->CreateComponent<FrameProfilerComponent>();
-
-            systemEntity->Init();
-            systemEntity->Activate(); // start frame component
-
-            m_numThreads = 0;
-            m_numRegistersReceived = 0;
-
-            // tick to frame 1 and collect all the samples
-            app.Tick();
-            EXPECT_EQ(0, m_numThreads);
-            EXPECT_EQ(0, m_numRegistersReceived);
-
-            int numIterations = 10000;
-            {
-                AZStd::thread t1(AZStd::bind(&FrameProfilerComponentTest::Profile1, this, numIterations));
-                AZStd::thread t2(AZStd::bind(&FrameProfilerComponentTest::Profile1, this, numIterations));
-                AZStd::thread t3(AZStd::bind(&FrameProfilerComponentTest::Profile1, this, numIterations));
-                AZStd::thread t4(AZStd::bind(&FrameProfilerComponentTest::Profile1, this, numIterations));
-
-                t1.join();
-                t2.join();
-                t3.join();
-                t4.join();
-            }
-
-            // tick to frame 2 and collect all the samples
-            app.Tick();
-
-            EXPECT_EQ(4, m_numThreads);
-            EXPECT_EQ(m_numThreads * 3, m_numRegistersReceived);
-
-            FrameProfilerBus::Handler::BusDisconnect();
-
-            app.Destroy();
-        }
-
-        size_t m_numRegistersReceived;
-        size_t m_numThreads;
-    };
-
-#if AZ_TRAIT_DISABLE_FAILED_FRAMEPROFILER_TEST
-    TEST_F(FrameProfilerComponentTest, DISABLED_Test)
-#else
-    TEST_F(FrameProfilerComponentTest, Test)
-#endif
-    {
-        run();
-    }
-
     class SimpleEntityRefTestComponent
         : public Component
     {

From 11d4543442aa7de56049c064f0dabcb969b0ec13 Mon Sep 17 00:00:00 2001
From: Jeremy Ong <jcong@amazon.com>
Date: Wed, 18 Aug 2021 15:00:00 -0600
Subject: [PATCH 30/37] Reintroduce StatisticalProfiler and associated classes
 in deactivated state

Signed-off-by: Jeremy Ong <jcong@amazon.com>
---
 .../Statistics/RunningStatisticsManager.cpp   | 106 +++
 .../AzCore/Statistics/StatisticalProfiler.h   | 255 ++++++
 .../Statistics/StatisticalProfilerProxy.h     | 164 ++++
 ...tatisticalProfilerProxySystemComponent.cpp |  66 ++
 .../StatisticalProfilerProxySystemComponent.h |  67 ++
 .../AzCore/Statistics/StatisticsManager.h     | 200 +++++
 .../Statistics/TimeDataStatisticsManager.cpp  |  49 +
 .../Statistics/TimeDataStatisticsManager.h    |  51 ++
 .../AzCore/AzCore/azcore_files.cmake          |   7 +
 .../AzCore/Tests/StatisticalProfiler.cpp      | 847 ++++++++++++++++++
 Code/Framework/AzCore/Tests/Statistics.cpp    | 263 ++++++
 .../AzCore/Tests/TimeDataStatistics.cpp       | 207 +++++
 .../AzCore/Tests/azcoretests_files.cmake      |   2 +
 .../Include/Atom/Utils/StableDynamicArray.h   |   1 -
 14 files changed, 2284 insertions(+), 1 deletion(-)
 create mode 100644 Code/Framework/AzCore/AzCore/Statistics/RunningStatisticsManager.cpp
 create mode 100644 Code/Framework/AzCore/AzCore/Statistics/StatisticalProfiler.h
 create mode 100644 Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxy.h
 create mode 100644 Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxySystemComponent.cpp
 create mode 100644 Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxySystemComponent.h
 create mode 100644 Code/Framework/AzCore/AzCore/Statistics/StatisticsManager.h
 create mode 100644 Code/Framework/AzCore/AzCore/Statistics/TimeDataStatisticsManager.cpp
 create mode 100644 Code/Framework/AzCore/AzCore/Statistics/TimeDataStatisticsManager.h
 create mode 100644 Code/Framework/AzCore/Tests/StatisticalProfiler.cpp
 create mode 100644 Code/Framework/AzCore/Tests/Statistics.cpp
 create mode 100644 Code/Framework/AzCore/Tests/TimeDataStatistics.cpp

diff --git a/Code/Framework/AzCore/AzCore/Statistics/RunningStatisticsManager.cpp b/Code/Framework/AzCore/AzCore/Statistics/RunningStatisticsManager.cpp
new file mode 100644
index 0000000000..52085d98e7
--- /dev/null
+++ b/Code/Framework/AzCore/AzCore/Statistics/RunningStatisticsManager.cpp
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include "RunningStatisticsManager.h"
+
+namespace AzFramework
+{
+    namespace Statistics
+    {
+        bool RunningStatisticsManager::ContainsStatistic(const AZStd::string& name)
+        {
+            auto iterator = m_statisticsNamesToIndexMap.find(name);
+            return iterator != m_statisticsNamesToIndexMap.end();
+        }
+
+        bool RunningStatisticsManager::AddStatistic(const AZStd::string& name, const AZStd::string& units)
+        {
+            if (ContainsStatistic(name))
+            {
+                return false;
+            }
+            AddStatisticValidated(name, units);
+            return true;
+        }
+
+        void RunningStatisticsManager::RemoveStatistic(const AZStd::string& name)
+        {
+            auto iterator = m_statisticsNamesToIndexMap.find(name);
+            if (iterator == m_statisticsNamesToIndexMap.end())
+            {
+                return;
+            }
+            AZ::u32 itemIndex = iterator->second;
+            m_statistics.erase(m_statistics.begin() + itemIndex);
+            m_statisticsNamesToIndexMap.erase(iterator);
+            //Update the indices in m_statisticsNamesToIndexMap.
+            while (itemIndex < m_statistics.size())
+            {
+                const AZStd::string& statName = m_statistics[itemIndex].GetName();
+                m_statisticsNamesToIndexMap[statName] = itemIndex;
+                ++itemIndex;
+            }
+        }
+
+        void RunningStatisticsManager::ResetStatistic(const AZStd::string& name)
+        {
+            NamedRunningStatistic* stat = GetStatistic(name);
+            if (!stat)
+            {
+                return;
+            }
+            stat->Reset();
+        }
+
+        void RunningStatisticsManager::ResetAllStatistics()
+        {
+            for (NamedRunningStatistic& stat : m_statistics)
+            {
+                stat.Reset();
+            }
+        }
+
+        void RunningStatisticsManager::PushSampleForStatistic(const AZStd::string& name, double value)
+        {
+            NamedRunningStatistic* stat = GetStatistic(name);
+            if (!stat)
+            {
+                return;
+            }
+            stat->PushSample(value);
+        }
+
+        NamedRunningStatistic* RunningStatisticsManager::GetStatistic(const AZStd::string& name, AZ::u32* indexOut)
+        {
+            auto iterator = m_statisticsNamesToIndexMap.find(name);
+            if (iterator == m_statisticsNamesToIndexMap.end())
+            {
+                return nullptr;
+            }
+            const AZ::u32 index = iterator->second;
+            if (indexOut)
+            {
+                *indexOut = index;
+            }
+            return &m_statistics[index];
+        }
+
+        const AZStd::vector<NamedRunningStatistic>& RunningStatisticsManager::GetAllStatistics() const
+        {
+            return m_statistics;
+        }
+
+        void RunningStatisticsManager::AddStatisticValidated(const AZStd::string& name, const AZStd::string& units)
+        {
+            m_statistics.emplace_back(NamedRunningStatistic(name, units));
+            const AZ::u32 itemIndex = static_cast<AZ::u32>(m_statistics.size() - 1);
+            m_statisticsNamesToIndexMap[name] = itemIndex;
+        }
+
+    }//namespace Statistics
+}//namespace AzFramework
diff --git a/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfiler.h b/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfiler.h
new file mode 100644
index 0000000000..2d8823c6e8
--- /dev/null
+++ b/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfiler.h
@@ -0,0 +1,255 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+#pragma once
+
+#include <AzCore/EBus/BusImpl.h> //Just to get AZ::NullMutex
+#include <AzCore/std/chrono/types.h>
+#include <AzCore/Statistics/StatisticsManager.h>
+#include <AzCore/std/parallel/scoped_lock.h>
+
+namespace AZ
+{
+    namespace Statistics
+    {
+        //! A helper class that facilitates collecting time spent in blocks (scopes) of code
+        //! and aggregating the measured times as running statistics.
+        //!
+        //! See "StatisticalProfilerProxy.h" for more explanations on the meaning of Statistical Profiling.
+        //!
+        //! The StatisticalProfiler was made as a template to accommodate for several performance needs...
+        //! If all the code that is being profiled is single threaded and you want to identify
+        //! each statistic by its string name, then the default StatisticalProfiler<> works for you.
+        //! If using a map<strings, stat> is too much of what you can afford, then index your
+        //! statistics with an integer or crc32 and your code profiler should be declared as
+        //! StatisticalProfiler<AZ::Crc32>.
+        //! For multi-threaded cases and indexing statistic with Crc32 you can have a profiler like this:
+        //! StatisticalProfiler<AZ::Crc32, AZStd::mutex>.
+        //! The UnitTests mentioned in the first paragraph do benchmarks of different combinations
+        //! of indexing and synchronization primitives.
+        //!
+        //! Even though you can create, subclass and use your own StatisticalProfiler<*,*>, there
+        //! are some things to consider when working with the StatisticalProfilerProxy:
+        //! The StatisticalProfilerProxy OWNS an array of StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex>.
+        //! You can "manage" one of those StatisticalProfiler by getting a reference to it and
+        //! add Running statistics etc. See The TerrainProfilers mentioned above to see concrete use
+        //! cases on how to work with the StatisticalProfilerProxy.
+        template <class StatIdType = AZStd::string, class MutexType = AZ::NullMutex>
+        class StatisticalProfiler
+        {
+        public:
+
+            //! A Convenience class used to measure time performance of scopes of code
+            //! with constructor/destructor. Suitable to be used as part of a macro
+            //! to facilitate its usage.
+            class TimedScope
+            {
+            public:
+                TimedScope() = delete;
+
+                TimedScope(StatisticalProfiler& profiler, const StatIdType& statId)
+                    : m_profiler(profiler), m_statId(statId)
+                {
+                    m_startTime = AZStd::chrono::high_resolution_clock::now();
+                }
+
+                ~TimedScope()
+                {
+                    AZStd::chrono::system_clock::time_point stopTime = AZStd::chrono::high_resolution_clock::now();
+                    AZStd::chrono::microseconds duration = stopTime - m_startTime;
+                    m_profiler.PushSample(m_statId, static_cast<double>(duration.count()));
+                }
+
+            private:
+                StatisticalProfiler& m_profiler;
+                const StatIdType& m_statId;
+                AZStd::chrono::system_clock::time_point m_startTime;
+            }; //class TimedScope
+
+            friend class TimedScope;
+
+            StatisticalProfiler()
+            {
+            }
+
+            StatisticalProfiler(const StatisticalProfiler& other)
+            {
+                m_statisticsManager = other.m_statisticsManager;
+                m_statsVector.clear();
+                m_perFrameAggregates.clear();
+            }
+
+            StatisticalProfiler(StatisticalProfiler&& other)
+            {
+                m_statisticsManager = AZStd::move(other.m_statisticsManager);
+                m_perFrameAggregates = AZStd::move(other.m_perFrameAggregates);
+            }
+
+            virtual ~StatisticalProfiler()
+            {
+            }
+
+            AZ::Statistics::StatisticsManager<StatIdType>& GetStatsManager()
+            {
+                return m_statisticsManager;
+            }
+
+            //! Should be called once per frame, it runs over all existing timed stats in m_statsForPerFrameCalculation
+            //! and accumulates all the values as a single stat per frame.
+            double SummarizePerFrameStats()
+            {
+                AZStd::scoped_lock<MutexType> lock(m_mutex);
+
+                if (m_perFrameAggregates.size() < 1)
+                {
+                    return 0.0;
+                }
+
+                double allStatsSumMicroSecs = 0.0;
+
+                for (StatisticalAggregate& aggregate : m_perFrameAggregates)
+                {
+                    double statsSumMicroSecs = 0.0;
+                    for (const AZ::Statistics::NamedRunningStatistic* stat : aggregate.m_statsForPerFrameCalculation)
+                    {
+                        statsSumMicroSecs += stat->GetSum();
+                    }
+
+                    const double frameTime = statsSumMicroSecs - aggregate.m_prevAccumulatedSums;
+                    if (frameTime > 0.0)
+                    {
+                        aggregate.m_statPerFrame->PushSample(frameTime);
+                        aggregate.m_prevAccumulatedSums = statsSumMicroSecs;
+                    }
+                    allStatsSumMicroSecs += statsSumMicroSecs;
+                }
+
+                return allStatsSumMicroSecs;
+            }
+
+            void LogAndResetStats(const char* windowName)
+            {
+                AZStd::scoped_lock<MutexType> lock(m_mutex);
+
+                if (m_statsVector.size() != m_statisticsManager.GetCount())
+                {
+                    m_statsVector.clear();
+                    m_statisticsManager.GetAllStatistics(m_statsVector);
+                }
+
+                for (AZ::Statistics::NamedRunningStatistic* stat : m_statsVector)
+                {
+                    if (stat->GetNumSamples() == 0)
+                    {
+                        continue;
+                    }
+                    const AZStd::string& statReport = stat->GetFormatted();
+                    AZ_Printf(windowName, "%s\n", statReport.c_str());
+                    stat->Reset();
+                }
+                for (StatisticalAggregate& aggregate : m_perFrameAggregates)
+                {
+                    aggregate.m_prevAccumulatedSums = 0.0;
+                }
+            }
+
+            void PushSample(const StatIdType& statId, double value)
+            {
+                AZStd::scoped_lock<MutexType> lock(m_mutex);
+                AZ::Statistics::NamedRunningStatistic* stat = m_statisticsManager.GetStatistic(statId);
+                if (!stat)
+                {
+                    return;
+                }
+                stat->PushSample(value);
+            }
+
+            const AZ::Statistics::NamedRunningStatistic* GetStatistic(const StatIdType& statId)
+            {
+                return m_statisticsManager.GetStatistic(statId);
+            }
+
+            int AddPerFrameStatisticalAggregate(const AZStd::vector<StatIdType>& statIds,
+                const StatIdType& timePerFrameStatId,
+                const AZStd::string& timePerFrameStatName)
+            {
+                AZStd::scoped_lock<MutexType> lock(m_mutex);
+
+                m_perFrameAggregates.push_back(StatisticalAggregate());
+                StatisticalAggregate& aggregate = m_perFrameAggregates[m_perFrameAggregates.size() - 1];
+
+                int added_count = 0;
+                for (const StatIdType& statId : statIds)
+                {
+                    AZ::Statistics::NamedRunningStatistic* stat = m_statisticsManager.GetStatistic(statId);
+                    if (!stat)
+                    {
+                        continue;
+                    }
+                    auto const& itor = AZStd::find(aggregate.m_statsForPerFrameCalculation.begin(), aggregate.m_statsForPerFrameCalculation.end(), stat);
+                    if (itor != aggregate.m_statsForPerFrameCalculation.end())
+                    {
+                        continue;
+                    }
+                    aggregate.m_statsForPerFrameCalculation.push_back(stat);
+                    added_count++;
+                }
+
+                if (added_count < 1)
+                {
+                    m_perFrameAggregates.pop_back();
+                    return 0;
+                }
+
+                aggregate.m_statPerFrame = m_statisticsManager.AddStatistic(timePerFrameStatId, timePerFrameStatName, "us", true);
+                if (!aggregate.m_statPerFrame)
+                {
+                    AZ_Warning("StatisticalProfiler", false, "Per frame stat with name %s already exists\n", timePerFrameStatName.c_str());
+                    m_perFrameAggregates.pop_back();
+                    return 0;
+                }
+
+                return added_count;
+            }
+
+            const AZ::Statistics::NamedRunningStatistic* GetFirstStatPerFrame() const
+            {
+                if (m_perFrameAggregates.size() < 1)
+                {
+                    return nullptr;
+                }
+                return m_perFrameAggregates[0].m_statPerFrame;
+            }
+
+        protected:
+            //! Lock this before reading/writing to m_timeStatisticsManager, or else...
+            MutexType m_mutex;
+            AZ::Statistics::StatisticsManager<StatIdType> m_statisticsManager;
+            AZStd::vector<AZ::Statistics::NamedRunningStatistic*> m_statsVector;
+
+
+            struct StatisticalAggregate
+            {
+                StatisticalAggregate() : m_statPerFrame(nullptr), m_prevAccumulatedSums(0.0)
+                {
+
+                }
+                AZ::Statistics::NamedRunningStatistic* m_statPerFrame;
+                AZStd::vector<AZ::Statistics::NamedRunningStatistic*> m_statsForPerFrameCalculation;
+
+                //! This one is needed because running statistics are collected many times across
+                //! several frames. This value is used to calculate a per frame sample for @m_totalTimePerFrameStat,
+                //! by subtracting @m_prevAccumulatedSums from the accumulated sum in @m_statisticsManager. 
+                double m_prevAccumulatedSums;
+            };
+
+            AZStd::vector<StatisticalAggregate> m_perFrameAggregates;
+
+        }; //class StatisticalProfiler
+
+    }; //namespace Statistics
+}; //namespace AZ
diff --git a/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxy.h b/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxy.h
new file mode 100644
index 0000000000..5ea69b205c
--- /dev/null
+++ b/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxy.h
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+#pragma once
+
+#include <AzCore/std/chrono/types.h>
+#include <AzCore/std/parallel/shared_spin_mutex.h>
+#include <AzCore/std/parallel/scoped_lock.h>
+#include <AzCore/std/containers/bitset.h>
+#include <AzCore/std/string/string.h>
+#include <AzCore/Interface/Interface.h>
+#include <AzCore/Statistics/StatisticalProfiler.h>
+#include <AzCore/Debug/Profiler.h>
+
+
+#if !defined(AZ_PROFILE_TELEMETRY) && defined(AZ_STATISTICAL_PROFILING_ENABLED)
+
+#if defined(AZ_PROFILE_SCOPE)
+#undef AZ_PROFILE_SCOPE
+#endif // #if defined(AZ_PROFILE_SCOPE)
+
+#define AZ_PROFILE_SCOPE(profiler, scopeNameId) \
+    static const AZStd::string AZ_JOIN(blockName, __LINE__)(scopeNameId); \
+    AZ::Statistics::StatisticalProfilerProxy::TimedScope AZ_JOIN(scope, __LINE__)(profiler, AZ_JOIN(blockName, __LINE__));
+
+#endif //#if !defined(AZ_PROFILE_TELEMETRY)
+
+namespace AZ::Statistics
+{
+    using StatisticalProfilerId = uint32_t;
+
+    //! This AZ::Interface<> (Yes, it is an application wide singleton) owns an array of StatisticalProfilers.
+    //! When is this useful?
+    //! When you need to statistically profile code that runs across DLL boundaries.
+    //!
+    //! What is the meaning of "statistically profile" code?
+    //! In regular profiling with tools like RAD Telemetry, every execution of a profiled
+    //! scope of code will be captured when using AZ_PROFILE_SCOPE(). You can collect
+    //! very large amounts of data and do your own post processing and analysis in tools like Excel,etc.
+    //! In contrast, "statistical profiling" means that everytime AZ_PROFILE_SCOPE() is called,
+    //! the time spent in the given scope of code will be mathematically accumulated as part of a unique
+    //! Running statistic. Common statistical parameters like min, max, average, variance and standard deviation
+    //! are calculated on the fly. This approach reduces considerably the amount of data that is collected.
+    //! The data is recorded in the Game/Editor Log file.
+    //!
+    //! This StatisticalProfilerProxy should be used via the AZ_PROFILE_SCOPE() macro, and by using
+    //! this macro the developer gains the flexibility of switching at compile time between profiling
+    //! the code via RAD Telemetry or through statistical profiling.
+    //!
+    //! When creating a new statistical profiler add your category (aka profiler id) in Profiler.h (enum class ProfileCategory).
+    //! Get a reference of the statistical profiler with "GetProfiler(const StatisticalProfilerId& id)" using the profiler Id.
+    //! Once you get a reference to the profiler you can customize it, add Running statistics to it, etc.
+    //! Some class in your code will manage the reference to the statistical profiler and will determine
+    //! the policy on how often to log data to the game logs, etc. For example, by subclassing the TickBus Handler, etc.
+    //!
+    //! The StatisticalProfilerProxySystemComponent guarantees that the StatisticalProfilerProxy singleton exists
+    //! as soon as the AZ::Environment is fully initialized.
+    //! See StatisticalProfiler.h for more details and info.
+    class StatisticalProfilerProxy
+    {
+    public:
+        AZ_TYPE_INFO(StatisticalProfilerProxy, "{1103D0EB-1C32-4854-B9D9-40A2D65BDBD2}");
+
+        using StatIdType = AZStd::string;
+        using StatisticalProfilerType = StatisticalProfiler<StatIdType, AZStd::shared_spin_mutex>;
+
+        //! A Convenience class used to measure time performance of scopes of code
+        //! with constructor/destructor. Suitable to be used as part of a macro
+        //! to facilitate its usage.
+        class TimedScope
+        {
+        public:
+            TimedScope() = delete;
+
+            TimedScope(const StatisticalProfilerId profilerId, const StatIdType& statId)
+                : m_profilerId(profilerId)
+                , m_statId(statId)
+            {
+                if (!m_profilerProxy)
+                {
+                    m_profilerProxy = AZ::Interface<StatisticalProfilerProxy>::Get();
+                    if (!m_profilerProxy)
+                    {
+                        return;
+                    }
+                }
+                if (!m_profilerProxy->IsProfilerActive(profilerId))
+                {
+                    return;
+                }
+                m_startTime = AZStd::chrono::high_resolution_clock::now();
+            }
+            ~TimedScope()
+            {
+                if (!m_profilerProxy)
+                {
+                    return;
+                }
+                AZStd::chrono::system_clock::time_point stopTime = AZStd::chrono::high_resolution_clock::now();
+                AZStd::chrono::microseconds duration = stopTime - m_startTime;
+                m_profilerProxy->PushSample(m_profilerId, m_statId, static_cast<double>(duration.count()));
+            }
+
+            //! Required only for UnitTests
+            static void ClearCachedProxy()
+            {
+                m_profilerProxy = nullptr;
+            }
+
+        private:
+            static StatisticalProfilerProxy* m_profilerProxy;
+            const StatisticalProfilerId m_profilerId;
+            const StatIdType& m_statId;
+            AZStd::chrono::system_clock::time_point m_startTime;
+        }; // class TimedScope
+
+        friend class TimedScope;
+
+        StatisticalProfilerProxy()
+        {
+            // TODO:BUDGETS Query available budgets at registration time and create an associated profiler per type
+            AZ::Interface<StatisticalProfilerProxy>::Register(this);
+        }
+
+        virtual ~StatisticalProfilerProxy()
+        {
+            AZ::Interface<StatisticalProfilerProxy>::Unregister(this);
+        }
+
+        // Note that you have to delete these for safety reasons, you will trip a static_assert if you do not
+        StatisticalProfilerProxy(StatisticalProfilerProxy&&) = delete;
+        StatisticalProfilerProxy& operator=(StatisticalProfilerProxy&&) = delete;
+
+        bool IsProfilerActive(StatisticalProfilerId id) const
+        {
+            return m_activeProfilersFlag[static_cast<AZStd::size_t>(id)];
+        }
+
+        StatisticalProfilerType& GetProfiler(StatisticalProfilerId id)
+        {
+            return m_profilers[static_cast<AZStd::size_t>(id)];
+        }
+
+        void ActivateProfiler(StatisticalProfilerId id, bool activate)
+        {
+            m_activeProfilersFlag[static_cast<AZStd::size_t>(id)] = activate;
+        }
+
+        void PushSample(StatisticalProfilerId id, const StatIdType& statId, double value)
+        {
+            m_profilers[static_cast<AZStd::size_t>(id)].PushSample(statId, value);
+        }
+
+    private:
+        // TODO:BUDGETS the number of bits allocated here must be based on the number of budgets available at profiler registration time
+        AZStd::bitset<128> m_activeProfilersFlag;
+        AZStd::vector<StatisticalProfilerType> m_profilers;
+    }; // class StatisticalProfilerProxy
+
+}; // namespace AZ::Statistics
diff --git a/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxySystemComponent.cpp b/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxySystemComponent.cpp
new file mode 100644
index 0000000000..00bb97b745
--- /dev/null
+++ b/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxySystemComponent.cpp
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <AzCore/RTTI/BehaviorContext.h>
+#include <AzCore/Serialization/EditContext.h>
+#include <AzCore/Serialization/SerializeContext.h>
+#include "StatisticalProfilerProxySystemComponent.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+namespace AZ
+{
+    namespace Statistics
+    {
+        StatisticalProfilerProxy* StatisticalProfilerProxy::TimedScope::m_profilerProxy = nullptr;
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        void StatisticalProfilerProxySystemComponent::Reflect(AZ::ReflectContext* context)
+        {
+            if (AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
+            {
+                serializeContext->Class<StatisticalProfilerProxySystemComponent, AZ::Component>()
+                    ->Version(1);
+            }
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        void StatisticalProfilerProxySystemComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
+        {
+            provided.push_back(AZ_CRC("StatisticalProfilerService", 0x20066f73));
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        void StatisticalProfilerProxySystemComponent::GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible)
+        {
+            incompatible.push_back(AZ_CRC("StatisticalProfilerService", 0x20066f73));
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        StatisticalProfilerProxySystemComponent::StatisticalProfilerProxySystemComponent()
+            : m_StatisticalProfilerProxy(nullptr)
+        {
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        StatisticalProfilerProxySystemComponent::~StatisticalProfilerProxySystemComponent()
+        {
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        void StatisticalProfilerProxySystemComponent::Activate()
+        {
+            m_StatisticalProfilerProxy = new StatisticalProfilerProxy;
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        void StatisticalProfilerProxySystemComponent::Deactivate()
+        {
+            delete m_StatisticalProfilerProxy;
+        }
+    } //namespace Statistics
+} // namespace AZ
diff --git a/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxySystemComponent.h b/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxySystemComponent.h
new file mode 100644
index 0000000000..333e29e3b9
--- /dev/null
+++ b/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxySystemComponent.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+#pragma once
+
+#include <AzCore/Component/Component.h>
+#include "StatisticalProfilerProxy.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+namespace AZ
+{
+    namespace Statistics
+    {
+        ////////////////////////////////////////////////////////////////////////////////////////////////
+        //! This system component manages the globally unique StatisticalProfilerProxy instance.
+        //! And this is all this component does... it simply makes sure the StatisticalProfilerProxy exists.
+        class StatisticalProfilerProxySystemComponent : public AZ::Component
+        {
+        public:
+            ////////////////////////////////////////////////////////////////////////////////////////////
+            // AZ::Component Setup
+            AZ_COMPONENT(StatisticalProfilerProxySystemComponent, "{1E15565F-A5C1-4BF2-8AEE-D3880AC9E1EB}")
+
+            ////////////////////////////////////////////////////////////////////////////////////////////
+            //! \ref AZ::ComponentDescriptor::Reflect
+            static void Reflect(AZ::ReflectContext* reflection);
+
+            ////////////////////////////////////////////////////////////////////////////////////////////
+            //! \ref AZ::ComponentDescriptor::GetProvidedServices
+            static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided);
+
+            ////////////////////////////////////////////////////////////////////////////////////////////
+            //! \ref AZ::ComponentDescriptor::GetIncompatibleServices
+            static void GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible);
+
+            ////////////////////////////////////////////////////////////////////////////////////////////
+            //! Constructor
+            StatisticalProfilerProxySystemComponent();
+
+            ////////////////////////////////////////////////////////////////////////////////////////////
+            //! Destructor
+            ~StatisticalProfilerProxySystemComponent() override;
+
+        protected:
+            ////////////////////////////////////////////////////////////////////////////////////////////
+            //! \ref AZ::Component::Activate
+            void Activate() override;
+
+            ////////////////////////////////////////////////////////////////////////////////////////////
+            //! \ref AZ::Component::Deactivate
+            void Deactivate() override;
+
+        private:
+            ////////////////////////////////////////////////////////////////////////////////////////////
+            // Disable copy constructor
+            StatisticalProfilerProxySystemComponent(const StatisticalProfilerProxySystemComponent&) = delete;
+
+            ////////////////////////////////////////////////////////////////////////////////////////////
+            // The one and only StatisticalProfilerProxy (Which is itself an AZ::Interface<>)
+            StatisticalProfilerProxy* m_StatisticalProfilerProxy;
+        };
+    } //namespace Statistics
+} // namespace AZ
diff --git a/Code/Framework/AzCore/AzCore/Statistics/StatisticsManager.h b/Code/Framework/AzCore/AzCore/Statistics/StatisticsManager.h
new file mode 100644
index 0000000000..5984701f4e
--- /dev/null
+++ b/Code/Framework/AzCore/AzCore/Statistics/StatisticsManager.h
@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+#pragma once
+
+#include <AzCore/std/containers/vector.h>
+#include <AzCore/std/containers/unordered_map.h>
+
+#include "NamedRunningStatistic.h"
+
+namespace AZ
+{
+    namespace Statistics
+    {
+        /**
+         * @brief A Collection of Running Statistics, addressable by a hashable
+         *        class/primitive. e.g. AZ::Crc32, int, AZStd::string, etc.
+         *
+         */
+        template <class StatIdType = AZStd::string>
+        class StatisticsManager
+        {
+        public:
+            StatisticsManager() = default;
+
+            StatisticsManager(const StatisticsManager& other)
+            {
+                m_statistics.reserve(other.m_statistics.size());
+                for (auto const& it : other.m_statistics)
+                {
+                    const StatIdType& statId = it.first;
+                    const NamedRunningStatistic* stat = it.second;
+                    m_statistics[statId] = new NamedRunningStatistic(*stat);
+                }
+            }
+
+            virtual ~StatisticsManager()
+            {
+                Clear();
+            }
+
+            bool ContainsStatistic(const StatIdType& statId) const
+            {
+                auto iterator = m_statistics.find(statId);
+                return iterator != m_statistics.end();
+            }
+
+            AZ::u32 GetCount() const
+            {
+                return static_cast<AZ::u32>(m_statistics.size());
+            }
+
+            void GetAllStatistics(AZStd::vector<NamedRunningStatistic*>& vector)
+            {
+                for (auto const& it : m_statistics)
+                {
+                    NamedRunningStatistic* stat = it.second;
+                    vector.push_back(stat);
+                }
+            }
+
+            //! Helper method to apply units to statistics with empty units string.
+            AZ::u32 ApplyUnits(const AZStd::string& units)
+            {
+                AZ::u32 updatedCount = 0;
+                for (auto& it : m_statistics)
+                {
+                    NamedRunningStatistic* stat = it.second;
+                    if (stat->GetUnits().empty())
+                    {
+                        stat->UpdateUnits(units);
+                        updatedCount++;
+                    }
+                }
+                return updatedCount;
+            }
+
+            void Clear()
+            {
+                for (auto& it : m_statistics)
+                {
+                    NamedRunningStatistic* stat = it.second;
+                    delete stat;
+                }
+                m_statistics.clear();
+            }
+
+            /**
+             * Returns nullptr if a statistic with such name doesn't exist,
+             * otherwise returns a pointer to the statistic.
+             */
+            NamedRunningStatistic* GetStatistic(const StatIdType& statId)
+            {
+                auto iterator = m_statistics.find(statId);
+                if (iterator == m_statistics.end())
+                {
+                    return nullptr;
+                }
+                return iterator->second;
+            }
+
+            //! Returns false if a NamedRunningStatistic with such id already exists.
+            NamedRunningStatistic* AddStatistic(const StatIdType& statId, const bool failIfExist = true)
+            {
+                if (failIfExist)
+                {
+                    NamedRunningStatistic* prevStat = GetStatistic(statId);
+                    if (prevStat)
+                    {
+                        return nullptr;
+                    }
+                }
+                NamedRunningStatistic* stat = new NamedRunningStatistic();
+                m_statistics[statId] = stat;
+                return stat;
+            }
+
+            //! Returns false if a NamedRunningStatistic with such id already exists.
+            NamedRunningStatistic* AddStatistic(const StatIdType& statId, const AZStd::string& name, const AZStd::string& units, const bool failIfExist = true)
+            {
+                if (failIfExist)
+                {
+                    NamedRunningStatistic* prevStat = GetStatistic(statId);
+                    if (prevStat)
+                    {
+                        return nullptr;
+                    }
+                }
+                NamedRunningStatistic* stat = new NamedRunningStatistic(name, units);
+                m_statistics[statId] = stat;
+                return stat;
+            }
+
+            virtual void RemoveStatistic(const StatIdType& statId)
+            {
+                auto iterator = m_statistics.find(statId);
+                if (iterator == m_statistics.end())
+                {
+                    return;
+                }
+                NamedRunningStatistic* prevStat = iterator->second;
+                delete prevStat;
+                m_statistics.erase(iterator);
+            }
+
+            void ResetStatistic(const StatIdType& statId)
+            {
+                NamedRunningStatistic* stat = GetStatistic(statId);
+                if (!stat)
+                {
+                    return;
+                }
+                stat->Reset();
+            }
+
+            void ResetAllStatistics()
+            {
+                for (auto& it : m_statistics)
+                {
+                    NamedRunningStatistic* stat = it.second;
+                    stat->Reset();
+                }
+            }
+
+            void PushSampleForStatistic(const StatIdType& statId, double value)
+            {
+                NamedRunningStatistic* stat = GetStatistic(statId);
+                if (!stat)
+                {
+                    return;
+                }
+                stat->PushSample(value);
+            }
+
+            //! Expensive function because it does a reverse lookup
+            bool GetStatId(NamedRunningStatistic* searchStat, StatIdType& statIdOut) const
+            {
+                for (auto& it : m_statistics)
+                {
+                    NamedRunningStatistic* stat = it.second;
+                    if (stat == searchStat)
+                    {
+                        statIdOut = it.first;
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+
+        private:
+            ///Key: StatIdType, Value: NamedRunningStatistic*
+            AZStd::unordered_map<StatIdType, NamedRunningStatistic*> m_statistics;
+        };//class StatisticsManager
+    }//namespace Statistics
+}//namespace AZ
diff --git a/Code/Framework/AzCore/AzCore/Statistics/TimeDataStatisticsManager.cpp b/Code/Framework/AzCore/AzCore/Statistics/TimeDataStatisticsManager.cpp
new file mode 100644
index 0000000000..0e9b36a8b6
--- /dev/null
+++ b/Code/Framework/AzCore/AzCore/Statistics/TimeDataStatisticsManager.cpp
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include "TimeDataStatisticsManager.h"
+
+namespace AZ
+{
+    namespace Statistics
+    {
+        void TimeDataStatisticsManager::PushTimeDataSample(const char * registerName, const AZ::Debug::ProfilerRegister::TimeData& timeData)
+        {
+            const AZStd::string statName(registerName);
+            NamedRunningStatistic* statistic = GetStatistic(statName);
+            if (!statistic)
+            {
+                const AZStd::string units("us");
+                AddStatistic(statName, statName, units, false);
+                AZ::Debug::ProfilerRegister::TimeData zeroTimeData;
+                memset(&zeroTimeData, 0, sizeof(AZ::Debug::ProfilerRegister::TimeData));
+                m_previousTimeData[statName] = zeroTimeData;
+                statistic = GetStatistic(statName);
+                AZ_Assert(statistic != nullptr, "Fatal error adding a new statistic object");
+            }
+
+            const AZ::u64 accumulatedTime = timeData.m_time;
+            const AZ::s64 totalNumCalls = timeData.m_calls;
+            const AZ::u64 previousAccumulatedTime = m_previousTimeData[statName].m_time;
+            const AZ::s64 previousTotalNumCalls = m_previousTimeData[statName].m_calls;
+            const AZ::u64 deltaTime = accumulatedTime - previousAccumulatedTime;
+            const AZ::s64 deltaCalls = totalNumCalls - previousTotalNumCalls;
+            
+            if (deltaCalls == 0)
+            {
+                //This is the same old data. Let's skip it
+                return;
+            }
+
+            double newSample = static_cast<double>(deltaTime) / deltaCalls;
+
+            statistic->PushSample(newSample);
+            m_previousTimeData[statName] = timeData;
+        }
+    } //namespace Statistics
+} //namespace AZ
diff --git a/Code/Framework/AzCore/AzCore/Statistics/TimeDataStatisticsManager.h b/Code/Framework/AzCore/AzCore/Statistics/TimeDataStatisticsManager.h
new file mode 100644
index 0000000000..c9adc4de2f
--- /dev/null
+++ b/Code/Framework/AzCore/AzCore/Statistics/TimeDataStatisticsManager.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+#pragma once
+
+#include <AzCore/Debug/Profiler.h>
+#include <AzCore/Statistics/StatisticsManager.h>
+
+namespace AZ
+{
+    namespace Statistics
+    {
+        /**
+         * @brief Specialization useful for data generated with AZ::Debug::FrameProfileComponent
+         *
+         * Timer based data collection using AZ_PROFILE_TIMER(...), available in
+         * AzCore/Debug/Profiler.h can be collected when using AZ::Debug::FrameProfilerComponent
+         * and AZ::Debug::FrameProfilerBus. The method PushTimeDataSample(...) is a convenience
+         * to convert those Timer registers into a RunningStatistic.
+         *
+         * 
+         */
+        class TimeDataStatisticsManager : public StatisticsManager<>
+        {
+        public:
+            TimeDataStatisticsManager() = default;
+            virtual ~TimeDataStatisticsManager() = default;
+
+            /**
+             * @brief Adds one sample data to a specific running stat by name.
+             *
+             * This method is specialized to work with ProfilerRegister::TimeData that can be intercepted
+             * during AZ::Debug::FrameProfilerBus::OnFrameProfilerData().
+             * For each @param registerName a new RunningStat object is created if it doesn't exist.
+             *
+             * Adds the TimeData as one sample for its RunningStatistic.
+             */
+            void PushTimeDataSample(const char * registerName, const AZ::Debug::ProfilerRegister::TimeData& timeData);
+
+        protected:
+            ///We store here the previous value from the previous timer frame data.
+            ///This is necessary because AZ_PROFILER_TIMER is cumulative
+            ///and we need the time spent for each call.
+            AZStd::unordered_map<AZStd::string, AZ::Debug::ProfilerRegister::TimeData> m_previousTimeData;
+        };
+    } //namespace Statistics
+} //namespace AZ
diff --git a/Code/Framework/AzCore/AzCore/azcore_files.cmake b/Code/Framework/AzCore/AzCore/azcore_files.cmake
index c49c93f220..59db0d94fc 100644
--- a/Code/Framework/AzCore/AzCore/azcore_files.cmake
+++ b/Code/Framework/AzCore/AzCore/azcore_files.cmake
@@ -566,6 +566,13 @@ set(FILES
     Statistics/NamedRunningStatistic.h
     Statistics/RunningStatistic.cpp
     Statistics/RunningStatistic.h
+    Statistics/StatisticalProfiler.h
+    Statistics/StatisticalProfilerProxy.h
+    Statistics/StatisticalProfilerProxySystemComponent.cpp
+    Statistics/StatisticalProfilerProxySystemComponent.h
+    Statistics/StatisticsManager.h
+    Statistics/TimeDataStatisticsManager.cpp
+    Statistics/TimeDataStatisticsManager.h
     StringFunc/StringFunc.cpp
     StringFunc/StringFunc.h
     UserSettings/UserSettings.cpp
diff --git a/Code/Framework/AzCore/Tests/StatisticalProfiler.cpp b/Code/Framework/AzCore/Tests/StatisticalProfiler.cpp
new file mode 100644
index 0000000000..04e70d92a5
--- /dev/null
+++ b/Code/Framework/AzCore/Tests/StatisticalProfiler.cpp
@@ -0,0 +1,847 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+#include <AzCore/UnitTest/TestTypes.h>
+#include <AzCore/UnitTest/UnitTest.h>
+#include <AzTest/AzTest.h>
+
+#include <AzCore/Math/Crc.h>
+#include <AzCore/std/string/string.h>
+#include <AzCore/std/parallel/thread.h>
+#include <AzCore/std/parallel/shared_spin_mutex.h>
+#include <AzCore/Debug/TraceMessagesDrillerBus.h>
+
+#include <AzCore/Statistics/StatisticalProfilerProxy.h>
+
+//REMARK: The macros CODE_PROFILER_PROXY_PUSH_TIME and CODE_PROFILER_PUSH_TIME will be redefined
+//several times in this file to accommodate for the different specializations of the StatisticalProfiler<>
+//template.
+#ifdef CODE_PROFILER_PROXY_PUSH_TIME
+#undef CODE_PROFILER_PROXY_PUSH_TIME
+#endif
+
+#ifdef CODE_PROFILER_PUSH_TIME
+#undef CODE_PROFILER_PUSH_TIME
+#endif
+
+namespace UnitTest
+{
+    class StatisticalProfilerTest
+        : public AllocatorsFixture
+    {
+    public:
+
+        StatisticalProfilerTest()
+        {
+        }
+
+        void SetUp() override
+        {
+            AllocatorsFixture::SetUp();
+        }
+
+        ~StatisticalProfilerTest()
+        {
+        }
+
+        void TearDown() override
+        {
+            AllocatorsFixture::TearDown();
+        }
+
+    }; //class StatisticalProfilerTest
+
+    TEST_F(StatisticalProfilerTest, StatisticalProfilerStringNoMutex_ProfileCode_ValidateStatistics)
+    {
+//Helper macro.
+#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
+    AZ::Statistics::StatisticalProfiler<>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
+
+        AZ::Statistics::StatisticalProfiler<> profiler;
+
+        const AZStd::string statNamePerformance("PerformanceResult");
+        const AZStd::string statNameBlock("Block");
+
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNamePerformance, statNamePerformance, "us") != nullptr);
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNameBlock, statNameBlock, "us") != nullptr);
+
+        const int iter_count = 10;
+        {
+            CODE_PROFILER_PUSH_TIME(profiler, statNamePerformance)
+                int counter = 0;
+            for (int i = 0; i < iter_count; i++)
+            {
+                CODE_PROFILER_PUSH_TIME(profiler, statNameBlock)
+                    counter++;
+            }
+        }
+
+        ASSERT_TRUE(profiler.GetStatistic(statNamePerformance) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statNamePerformance)->GetNumSamples(), 1);
+
+        ASSERT_TRUE(profiler.GetStatistic(statNameBlock) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statNameBlock)->GetNumSamples(), iter_count);
+
+#undef CODE_PROFILER_PUSH_TIME
+
+    }
+
+    TEST_F(StatisticalProfilerTest, StatisticalProfilerCrc32NoMutex_ProfileCode_ValidateStatistics)
+    {
+        //Helper macro.
+#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
+    AZ::Statistics::StatisticalProfiler<AZ::Crc32>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
+
+        AZ::Statistics::StatisticalProfiler<AZ::Crc32> profiler;
+
+        const AZ::Crc32 statIdPerformance = AZ_CRC("PerformanceResult", 0xc1f29a10);
+        const AZStd::string statNamePerformance("PerformanceResult");
+
+        const AZ::Crc32 statIdBlock = AZ_CRC("Block", 0x831b9722);
+        const AZStd::string statNameBlock("Block");
+
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdPerformance, statNamePerformance, "us") != nullptr);
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdBlock, statNameBlock, "us") != nullptr);
+
+        const int iter_count = 10;
+        {
+            CODE_PROFILER_PUSH_TIME(profiler, statIdPerformance)
+                int counter = 0;
+            for (int i = 0; i < iter_count; i++)
+            {
+                CODE_PROFILER_PUSH_TIME(profiler, statIdBlock)
+                    counter++;
+            }
+        }
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdPerformance)->GetNumSamples(), 1);
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdBlock) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdBlock)->GetNumSamples(), iter_count);
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
+
+#undef CODE_PROFILER_PUSH_TIME
+
+    }
+
+    TEST_F(StatisticalProfilerTest, StatisticalProfilerStringWithSharedSpinMutex__ProfileCode_ValidateStatistics)
+    {
+        //Helper macro.
+#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
+    AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
+
+        AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex> profiler;
+
+        const AZStd::string statNamePerformance("PerformanceResult");
+        const AZStd::string statNameBlock("Block");
+
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNamePerformance, statNamePerformance, "us") != nullptr);
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNameBlock, statNameBlock, "us") != nullptr);
+
+        const int iter_count = 10;
+        {
+            CODE_PROFILER_PUSH_TIME(profiler, statNamePerformance)
+                int counter = 0;
+            for (int i = 0; i < iter_count; i++)
+            {
+                CODE_PROFILER_PUSH_TIME(profiler, statNameBlock)
+                    counter++;
+            }
+        }
+
+        ASSERT_TRUE(profiler.GetStatistic(statNamePerformance) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statNamePerformance)->GetNumSamples(), 1);
+
+        ASSERT_TRUE(profiler.GetStatistic(statNameBlock) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statNameBlock)->GetNumSamples(), iter_count);
+
+        ASSERT_TRUE(profiler.GetStatistic(statNamePerformance) != nullptr);
+
+#undef CODE_PROFILER_PUSH_TIME
+
+    }
+
+    TEST_F(StatisticalProfilerTest, StatisticalProfilerCrc32WithSharedSpinMutex__ProfileCode_ValidateStatistics)
+    {
+        //Helper macro.
+#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
+    AZ::Statistics::StatisticalProfiler<AZ::Crc32, AZStd::shared_spin_mutex>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
+
+        AZ::Statistics::StatisticalProfiler<AZ::Crc32, AZStd::shared_spin_mutex> profiler;
+
+        const AZ::Crc32 statIdPerformance = AZ_CRC("PerformanceResult", 0xc1f29a10);
+        const AZStd::string statNamePerformance("PerformanceResult");
+
+        const AZ::Crc32 statIdBlock = AZ_CRC("Block", 0x831b9722);
+        const AZStd::string statNameBlock("Block");
+
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdPerformance, statNamePerformance, "us") != nullptr);
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdBlock, statNameBlock, "us") != nullptr);
+
+        const int iter_count = 10;
+        {
+            CODE_PROFILER_PUSH_TIME(profiler, statIdPerformance)
+                int counter = 0;
+            for (int i = 0; i < iter_count; i++)
+            {
+                CODE_PROFILER_PUSH_TIME(profiler, statIdBlock)
+                    counter++;
+            }
+        }
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdPerformance)->GetNumSamples(), 1);
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdBlock) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdBlock)->GetNumSamples(), iter_count);
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
+
+#undef CODE_PROFILER_PUSH_TIME
+
+    }
+
+#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
+    AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
+
+    static void simple_thread01(AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex>* profiler, int loop_cnt)
+    {
+        const AZStd::string simple_thread("simple_thread1");
+        const AZStd::string simple_thread_loop("simple_thread1_loop");
+
+        CODE_PROFILER_PUSH_TIME(*profiler, simple_thread);
+
+        static int counter = 0;
+        for (int i = 0; i < loop_cnt; i++)
+        {
+            CODE_PROFILER_PUSH_TIME(*profiler, simple_thread_loop);
+            counter++;
+        }
+    }
+
+    static void simple_thread02(AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex>* profiler, int loop_cnt)
+    {
+        const AZStd::string simple_thread("simple_thread2");
+        const AZStd::string simple_thread_loop("simple_thread2_loop");
+
+        CODE_PROFILER_PUSH_TIME(*profiler, simple_thread);
+
+        static int counter = 0;
+        for (int i = 0; i < loop_cnt; i++)
+        {
+            CODE_PROFILER_PUSH_TIME(*profiler, simple_thread_loop);
+            counter++;
+        }
+    }
+
+    static void simple_thread03(AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex>* profiler, int loop_cnt)
+    {
+        const AZStd::string simple_thread("simple_thread3");
+        const AZStd::string simple_thread_loop("simple_thread3_loop");
+
+        CODE_PROFILER_PUSH_TIME(*profiler, simple_thread);
+
+        static int counter = 0;
+        for (int i = 0; i < loop_cnt; i++)
+        {
+            CODE_PROFILER_PUSH_TIME(*profiler, simple_thread_loop);
+            counter++;
+        }
+    }
+
+#undef CODE_PROFILER_PUSH_TIME
+
+    TEST_F(StatisticalProfilerTest, StatisticalProfilerStringWithSharedSpinMutex_RunProfiledThreads_ValidateStatistics)
+    {
+        AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex> profiler;
+
+        const AZStd::string statIdThread1 = "simple_thread1";
+        const AZStd::string statNameThread1("simple_thread1");
+        const AZStd::string statIdThread1Loop = "simple_thread1_loop";
+        const AZStd::string statNameThread1Loop("simple_thread1_loop");
+
+        const AZStd::string statIdThread2 = "simple_thread2";
+        const AZStd::string statNameThread2("simple_thread2");
+        const AZStd::string statIdThread2Loop = "simple_thread2_loop";
+        const AZStd::string statNameThread2Loop("simple_thread2_loop");
+
+        const AZStd::string statIdThread3 = "simple_thread3";
+        const AZStd::string statNameThread3("simple_thread3");
+        const AZStd::string statIdThread3Loop = "simple_thread3_loop";
+        const AZStd::string statNameThread3Loop("simple_thread3_loop");
+
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1, statNameThread1, "us"));
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1Loop, statNameThread1Loop, "us"));
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2, statNameThread2, "us"));
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2Loop, statNameThread2Loop, "us"));
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3, statNameThread3, "us"));
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3Loop, statNameThread3Loop, "us"));
+
+        //Let's kickoff the threads to see how much contention affects the profiler's performance.
+        const int iter_count = 10;
+        AZStd::thread t1(AZStd::bind(&simple_thread01, &profiler, iter_count));
+        AZStd::thread t2(AZStd::bind(&simple_thread02, &profiler, iter_count));
+        AZStd::thread t3(AZStd::bind(&simple_thread03, &profiler, iter_count));
+        t1.join();
+        t2.join();
+        t3.join();
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread1) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread1)->GetNumSamples(), 1);
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread1Loop) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread1Loop)->GetNumSamples(), iter_count);
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread2) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread2)->GetNumSamples(), 1);
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread2Loop) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread2Loop)->GetNumSamples(), iter_count);
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread3) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread3)->GetNumSamples(), 1);
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread3Loop) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread3Loop)->GetNumSamples(), iter_count);
+
+    }
+
+    TEST_F(StatisticalProfilerTest, StatisticalProfilerProxy_ProfileCode_ValidateStatistics)
+    {
+#define CODE_PROFILER_PROXY_PUSH_TIME(profiler, scopeNameId) \
+    AZ::Statistics::StatisticalProfilerProxy::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
+
+        AZ::Statistics::StatisticalProfilerProxy::TimedScope::ClearCachedProxy();
+        AZ::Statistics::StatisticalProfilerProxy profilerProxy;
+        AZ::Statistics::StatisticalProfilerProxy* proxy = AZ::Interface<AZ::Statistics::StatisticalProfilerProxy>::Get();
+        AZ::Statistics::StatisticalProfilerProxy::StatisticalProfilerType& profiler = proxy->GetProfiler(AZ::Debug::ProfileCategory::Terrain);
+
+        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdPerformance = "PerformanceResult";
+        const AZStd::string statNamePerformance("PerformanceResult");
+
+        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdBlock = "Block";
+        const AZStd::string statNameBlock("Block");
+
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdPerformance, statNamePerformance, "us") != nullptr);
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdBlock, statNameBlock, "us") != nullptr);
+
+        proxy->ActivateProfiler(AZ::Debug::ProfileCategory::Terrain, true);
+
+        const int iter_count = 10;
+        {
+            CODE_PROFILER_PROXY_PUSH_TIME(AZ::Debug::ProfileCategory::Terrain, statIdPerformance)
+            int counter = 0;
+            for (int i = 0; i < iter_count; i++)
+            {
+                CODE_PROFILER_PROXY_PUSH_TIME(AZ::Debug::ProfileCategory::Terrain, statIdBlock)
+                    counter++;
+            }
+        }
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdPerformance)->GetNumSamples(), 1);
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdBlock) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdBlock)->GetNumSamples(), iter_count);
+
+        //Clean Up
+        proxy->ActivateProfiler(AZ::Debug::ProfileCategory::Terrain, false);
+
+#undef CODE_PROFILER_PROXY_PUSH_TIME
+
+    }
+
+#define CODE_PROFILER_PROXY_PUSH_TIME(profiler, scopeNameId) \
+    AZ::Statistics::StatisticalProfilerProxy::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
+
+    static void simple_thread1(int loop_cnt)
+    {
+        const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread1("simple_thread1");
+        const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread1_loop("simple_thread1_loop");
+
+        CODE_PROFILER_PROXY_PUSH_TIME(AZ::Debug::ProfileCategory::Terrain, simple_thread1);
+
+        static int counter = 0;
+        for (int i = 0; i < loop_cnt; i++)
+        {
+            CODE_PROFILER_PROXY_PUSH_TIME(AZ::Debug::ProfileCategory::Terrain, simple_thread1_loop);
+            counter++;
+        }
+    }
+
+    static void simple_thread2(int loop_cnt)
+    {
+        const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread2("simple_thread2");
+        const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread2_loop("simple_thread2_loop");
+
+        CODE_PROFILER_PROXY_PUSH_TIME(AZ::Debug::ProfileCategory::Terrain, simple_thread2);
+
+        static int counter = 0;
+        for (int i = 0; i < loop_cnt; i++)
+        {
+            CODE_PROFILER_PROXY_PUSH_TIME(AZ::Debug::ProfileCategory::Terrain, simple_thread2_loop);
+            counter++;
+        }
+    }
+
+    static void simple_thread3(int loop_cnt)
+    {
+        const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread3("simple_thread3");
+        const AZ::Statistics::StatisticalProfilerProxy::StatIdType simple_thread3_loop("simple_thread3_loop");
+
+        CODE_PROFILER_PROXY_PUSH_TIME(AZ::Debug::ProfileCategory::Terrain, simple_thread3);
+
+        static int counter = 0;
+        for (int i = 0; i < loop_cnt; i++)
+        {
+            CODE_PROFILER_PROXY_PUSH_TIME(AZ::Debug::ProfileCategory::Terrain, simple_thread3_loop);
+        }
+    }
+
+#undef CODE_PROFILER_PROXY_PUSH_TIME
+
+    TEST_F(StatisticalProfilerTest, StatisticalProfilerProxy3_RunProfiledThreads_ValidateStatistics)
+    {
+        AZ::Statistics::StatisticalProfilerProxy::TimedScope::ClearCachedProxy();
+        AZ::Statistics::StatisticalProfilerProxy profilerProxy;
+        AZ::Statistics::StatisticalProfilerProxy* proxy = AZ::Interface<AZ::Statistics::StatisticalProfilerProxy>::Get();
+        AZ::Statistics::StatisticalProfilerProxy::StatisticalProfilerType& profiler = proxy->GetProfiler(AZ::Debug::ProfileCategory::Terrain);
+
+        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread1 = "simple_thread1";
+        const AZStd::string statNameThread1("simple_thread1");
+        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread1Loop = "simple_thread1_loop";
+        const AZStd::string statNameThread1Loop("simple_thread1_loop");
+
+        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread2 = "simple_thread2";
+        const AZStd::string statNameThread2("simple_thread2");
+        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread2Loop = "simple_thread2_loop";
+        const AZStd::string statNameThread2Loop("simple_thread2_loop");
+
+        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread3 = "simple_thread3";
+        const AZStd::string statNameThread3("simple_thread3");
+        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread3Loop = "simple_thread3_loop";
+        const AZStd::string statNameThread3Loop("simple_thread3_loop");
+
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1, statNameThread1, "us"));
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1Loop, statNameThread1Loop, "us"));
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2, statNameThread2, "us"));
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2Loop, statNameThread2Loop, "us"));
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3, statNameThread3, "us"));
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3Loop, statNameThread3Loop, "us"));
+
+        proxy->ActivateProfiler(AZ::Debug::ProfileCategory::Terrain, true);
+
+        //Let's kickoff the threads to see how much contention affects the profiler's performance.
+        const int iter_count = 10;
+        AZStd::thread t1(AZStd::bind(&simple_thread1, iter_count));
+        AZStd::thread t2(AZStd::bind(&simple_thread2, iter_count));
+        AZStd::thread t3(AZStd::bind(&simple_thread3, iter_count));
+        t1.join();
+        t2.join();
+        t3.join();
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread1) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread1)->GetNumSamples(), 1);
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread1Loop) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread1Loop)->GetNumSamples(), iter_count);
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread2) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread2)->GetNumSamples(), 1);
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread2Loop) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread2Loop)->GetNumSamples(), iter_count);
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread3) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread3)->GetNumSamples(), 1);
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread3Loop) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread3Loop)->GetNumSamples(), iter_count);
+
+        //Clean Up
+        proxy->ActivateProfiler(AZ::Debug::ProfileCategory::Terrain, false);
+    }
+
+    /** Trace message handler to track messages during tests
+*/
+    struct MyTraceMessageSink final
+        : public AZ::Debug::TraceMessageDrillerBus::Handler
+    {
+        MyTraceMessageSink()
+        {
+            AZ::Debug::TraceMessageDrillerBus::Handler::BusConnect();
+        }
+
+        ~MyTraceMessageSink()
+        {
+            AZ::Debug::TraceMessageDrillerBus::Handler::BusDisconnect();
+        }
+
+        //////////////////////////////////////////////////////////////////////////
+        // TraceMessageDrillerBus
+        void OnPrintf(const char* window, const char* message) override
+        {
+            OnOutput(window, message);
+        }
+
+        void OnOutput(const char* window, const char* message) override
+        {
+            printf("%s: %s\n", window, message);
+        }
+    }; //struct MyTraceMessageSink
+
+    class Suite_StatisticalProfilerPerformance
+        : public AllocatorsFixture
+    {
+    public:
+        MyTraceMessageSink* m_testSink;
+
+        Suite_StatisticalProfilerPerformance() :m_testSink(nullptr)
+        {
+        }
+
+        void SetUp() override
+        {
+            AllocatorsFixture::SetUp();
+            m_testSink = new MyTraceMessageSink();
+        }
+
+        ~Suite_StatisticalProfilerPerformance()
+        {
+        }
+
+        void TearDown() override
+        {
+            // clearing up memory
+            delete m_testSink;
+            AllocatorsFixture::TearDown();
+        }
+
+    }; //class Suite_StatisticalProfilerPerformance
+
+    TEST_F(Suite_StatisticalProfilerPerformance, StatisticalProfilerStringNoMutex_1ThreadPerformance)
+    {
+        //Helper macro.
+#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
+    AZ::Statistics::StatisticalProfiler<>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
+
+        AZ::Statistics::StatisticalProfiler<> profiler;
+
+        const AZStd::string statNamePerformance("PerformanceResult");
+        const AZStd::string statNameBlock("Block");
+
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNamePerformance, statNamePerformance, "us") != nullptr);
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNameBlock, statNameBlock, "us") != nullptr);
+
+        const int iter_count = 1000000;
+        {
+            CODE_PROFILER_PUSH_TIME(profiler, statNamePerformance)
+                int counter = 0;
+            for (int i = 0; i < iter_count; i++)
+            {
+                CODE_PROFILER_PUSH_TIME(profiler, statNameBlock)
+                    counter++;
+            }
+        }
+
+        ASSERT_TRUE(profiler.GetStatistic(statNamePerformance) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statNamePerformance)->GetNumSamples(), 1);
+
+        ASSERT_TRUE(profiler.GetStatistic(statNameBlock) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statNameBlock)->GetNumSamples(), iter_count);
+
+        profiler.LogAndResetStats("StatisticalProfilerStringNoMutex");
+
+        ASSERT_TRUE(profiler.GetStatistic(statNamePerformance) != nullptr);
+
+#undef CODE_PROFILER_PUSH_TIME
+
+    }
+
+    TEST_F(Suite_StatisticalProfilerPerformance, StatisticalProfilerCrc32NoMutex_1ThreadPerformance)
+    {
+        //Helper macro.
+#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
+    AZ::Statistics::StatisticalProfiler<AZ::Crc32>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
+
+        AZ::Statistics::StatisticalProfiler<AZ::Crc32> profiler;
+
+        const AZ::Crc32 statIdPerformance = AZ_CRC("PerformanceResult", 0xc1f29a10);
+        const AZStd::string statNamePerformance("PerformanceResult");
+
+        const AZ::Crc32 statIdBlock = AZ_CRC("Block", 0x831b9722);
+        const AZStd::string statNameBlock("Block");
+
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdPerformance, statNamePerformance, "us") != nullptr);
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdBlock, statNameBlock, "us") != nullptr);
+
+        const int iter_count = 1000000;
+        {
+            CODE_PROFILER_PUSH_TIME(profiler, statIdPerformance)
+                int counter = 0;
+            for (int i = 0; i < iter_count; i++)
+            {
+                CODE_PROFILER_PUSH_TIME(profiler, statIdBlock)
+                    counter++;
+            }
+        }
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdPerformance)->GetNumSamples(), 1);
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdBlock) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdBlock)->GetNumSamples(), iter_count);
+
+        profiler.LogAndResetStats("StatisticalProfilerCrc32NoMutex");
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
+
+#undef CODE_PROFILER_PUSH_TIME
+
+    }
+
+    TEST_F(Suite_StatisticalProfilerPerformance, StatisticalProfilerStringWithSharedSpinMutex_1ThreadPerformance)
+    {
+        //Helper macro.
+#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
+    AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
+
+        AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex> profiler;
+
+        const AZStd::string statNamePerformance("PerformanceResult");
+        const AZStd::string statNameBlock("Block");
+
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNamePerformance, statNamePerformance, "us") != nullptr);
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statNameBlock, statNameBlock, "us") != nullptr);
+
+        const int iter_count = 1000000;
+        {
+            CODE_PROFILER_PUSH_TIME(profiler, statNamePerformance)
+                int counter = 0;
+            for (int i = 0; i < iter_count; i++)
+            {
+                CODE_PROFILER_PUSH_TIME(profiler, statNameBlock)
+                    counter++;
+            }
+        }
+
+        ASSERT_TRUE(profiler.GetStatistic(statNamePerformance) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statNamePerformance)->GetNumSamples(), 1);
+
+        ASSERT_TRUE(profiler.GetStatistic(statNameBlock) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statNameBlock)->GetNumSamples(), iter_count);
+
+        profiler.LogAndResetStats("StatisticalProfilerStringWithSharedSpinMutex");
+
+        ASSERT_TRUE(profiler.GetStatistic(statNamePerformance) != nullptr);
+
+#undef CODE_PROFILER_PUSH_TIME
+
+    }
+
+    TEST_F(Suite_StatisticalProfilerPerformance, StatisticalProfilerCrc32WithSharedSpinMutex_1ThreadPerformance)
+    {
+        //Helper macro.
+#define CODE_PROFILER_PUSH_TIME(profiler, scopeNameId) \
+    AZ::Statistics::StatisticalProfiler<AZ::Crc32, AZStd::shared_spin_mutex>::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
+
+        AZ::Statistics::StatisticalProfiler<AZ::Crc32, AZStd::shared_spin_mutex> profiler;
+
+        const AZ::Crc32 statIdPerformance = AZ_CRC("PerformanceResult", 0xc1f29a10);
+        const AZStd::string statNamePerformance("PerformanceResult");
+
+        const AZ::Crc32 statIdBlock = AZ_CRC("Block", 0x831b9722);
+        const AZStd::string statNameBlock("Block");
+
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdPerformance, statNamePerformance, "us") != nullptr);
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdBlock, statNameBlock, "us") != nullptr);
+
+        const int iter_count = 1000000;
+        {
+            CODE_PROFILER_PUSH_TIME(profiler, statIdPerformance)
+                int counter = 0;
+            for (int i = 0; i < iter_count; i++)
+            {
+                CODE_PROFILER_PUSH_TIME(profiler, statIdBlock)
+                    counter++;
+            }
+        }
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdPerformance)->GetNumSamples(), 1);
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdBlock) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdBlock)->GetNumSamples(), iter_count);
+
+        profiler.LogAndResetStats("StatisticalProfilerCrc32WithSharedSpinMutex");
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
+
+#undef CODE_PROFILER_PUSH_TIME
+
+    }
+
+    TEST_F(Suite_StatisticalProfilerPerformance, StatisticalProfilerStringWithSharedSpinMutex3Threads_3ThreadsPerformance)
+    {
+        AZ::Statistics::StatisticalProfiler<AZStd::string, AZStd::shared_spin_mutex> profiler;
+
+        const AZStd::string statIdThread1 = "simple_thread1";
+        const AZStd::string statNameThread1("simple_thread1");
+        const AZStd::string statIdThread1Loop = "simple_thread1_loop";
+        const AZStd::string statNameThread1Loop("simple_thread1_loop");
+
+        const AZStd::string statIdThread2 = "simple_thread2";
+        const AZStd::string statNameThread2("simple_thread2");
+        const AZStd::string statIdThread2Loop = "simple_thread2_loop";
+        const AZStd::string statNameThread2Loop("simple_thread2_loop");
+
+        const AZStd::string statIdThread3 = "simple_thread3";
+        const AZStd::string statNameThread3("simple_thread3");
+        const AZStd::string statIdThread3Loop = "simple_thread3_loop";
+        const AZStd::string statNameThread3Loop("simple_thread3_loop");
+
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1, statNameThread1, "us"));
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1Loop, statNameThread1Loop, "us"));
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2, statNameThread2, "us"));
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2Loop, statNameThread2Loop, "us"));
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3, statNameThread3, "us"));
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3Loop, statNameThread3Loop, "us"));
+
+        //Let's kickoff the threads to see how much contention affects the profiler's performance.
+        const int iter_count = 1000000;
+        AZStd::thread t1(AZStd::bind(&simple_thread01, &profiler, iter_count));
+        AZStd::thread t2(AZStd::bind(&simple_thread02, &profiler, iter_count));
+        AZStd::thread t3(AZStd::bind(&simple_thread03, &profiler, iter_count));
+        t1.join();
+        t2.join();
+        t3.join();
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread1) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread1)->GetNumSamples(), 1);
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread1Loop) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread1Loop)->GetNumSamples(), iter_count);
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread2) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread2)->GetNumSamples(), 1);
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread2Loop) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread2Loop)->GetNumSamples(), iter_count);
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread3) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread3)->GetNumSamples(), 1);
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread3Loop) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread3Loop)->GetNumSamples(), iter_count);
+
+        profiler.LogAndResetStats("3_Threads_StatisticalProfiler");
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread1) != nullptr);
+
+    }
+
+#define CODE_PROFILER_PROXY_PUSH_TIME(profiler, scopeNameId) \
+    AZ::Statistics::StatisticalProfilerProxy::TimedScope AZ_JOIN(scope, __LINE__)(profiler, scopeNameId);
+
+    TEST_F(Suite_StatisticalProfilerPerformance, StatisticalProfilerProxy_1ThreadPerformance)
+    {
+        AZ::Statistics::StatisticalProfilerProxy::TimedScope::ClearCachedProxy();
+        AZ::Statistics::StatisticalProfilerProxy profilerProxy;
+        AZ::Statistics::StatisticalProfilerProxy* proxy = AZ::Interface<AZ::Statistics::StatisticalProfilerProxy>::Get();
+        AZ::Statistics::StatisticalProfilerProxy::StatisticalProfilerType& profiler = proxy->GetProfiler(AZ::Debug::ProfileCategory::Terrain);
+
+        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdPerformance = "PerformanceResult";
+        const AZStd::string statNamePerformance("PerformanceResult");
+
+        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdBlock = "Block";
+        const AZStd::string statNameBlock("Block");
+
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdPerformance, statNamePerformance, "us") != nullptr);
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdBlock, statNameBlock, "us") != nullptr);
+
+        proxy->ActivateProfiler(AZ::Debug::ProfileCategory::Terrain, true);
+
+        const int iter_count = 1000000;
+        {
+            CODE_PROFILER_PROXY_PUSH_TIME(AZ::Debug::ProfileCategory::Terrain, statIdPerformance)
+                int counter = 0;
+            for (int i = 0; i < iter_count; i++)
+            {
+                CODE_PROFILER_PROXY_PUSH_TIME(AZ::Debug::ProfileCategory::Terrain, statIdBlock)
+                    counter++;
+            }
+        }
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdPerformance) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdPerformance)->GetNumSamples(), 1);
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdBlock) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdBlock)->GetNumSamples(), iter_count);
+
+        profiler.LogAndResetStats("StatisticalProfilerProxy");
+
+        //Clean Up
+        proxy->ActivateProfiler(AZ::Debug::ProfileCategory::Terrain, false);
+    }
+
+#undef CODE_PROFILER_PROXY_PUSH_TIME
+
+    TEST_F(Suite_StatisticalProfilerPerformance, StatisticalProfilerProxy_3ThreadsPerformance)
+    {
+        AZ::Statistics::StatisticalProfilerProxy::TimedScope::ClearCachedProxy();
+        AZ::Statistics::StatisticalProfilerProxy profilerProxy;
+        AZ::Statistics::StatisticalProfilerProxy* proxy = AZ::Interface<AZ::Statistics::StatisticalProfilerProxy>::Get();
+        AZ::Statistics::StatisticalProfilerProxy::StatisticalProfilerType& profiler = proxy->GetProfiler(AZ::Debug::ProfileCategory::Terrain);
+
+        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread1 = "simple_thread1";
+        const AZStd::string statNameThread1("simple_thread1");
+        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread1Loop = "simple_thread1_loop";
+        const AZStd::string statNameThread1Loop("simple_thread1_loop");
+
+        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread2 = "simple_thread2";
+        const AZStd::string statNameThread2("simple_thread2");
+        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread2Loop = "simple_thread2_loop";
+        const AZStd::string statNameThread2Loop("simple_thread2_loop");
+
+        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread3 = "simple_thread3";
+        const AZStd::string statNameThread3("simple_thread3");
+        const AZ::Statistics::StatisticalProfilerProxy::StatIdType statIdThread3Loop = "simple_thread3_loop";
+        const AZStd::string statNameThread3Loop("simple_thread3_loop");
+
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1, statNameThread1, "us"));
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread1Loop, statNameThread1Loop, "us"));
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2, statNameThread2, "us"));
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread2Loop, statNameThread2Loop, "us"));
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3, statNameThread3, "us"));
+        ASSERT_TRUE(profiler.GetStatsManager().AddStatistic(statIdThread3Loop, statNameThread3Loop, "us"));
+
+        proxy->ActivateProfiler(AZ::Debug::ProfileCategory::Terrain, true);
+
+        //Let's kickoff the threads to see how much contention affects the profiler's performance.
+        const int iter_count = 1000000;
+        AZStd::thread t1(AZStd::bind(&simple_thread1, iter_count));
+        AZStd::thread t2(AZStd::bind(&simple_thread2, iter_count));
+        AZStd::thread t3(AZStd::bind(&simple_thread3, iter_count));
+        t1.join();
+        t2.join();
+        t3.join();
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread1) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread1)->GetNumSamples(), 1);
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread1Loop) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread1Loop)->GetNumSamples(), iter_count);
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread2) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread2)->GetNumSamples(), 1);
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread2Loop) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread2Loop)->GetNumSamples(), iter_count);
+
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread3) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread3)->GetNumSamples(), 1);
+        ASSERT_TRUE(profiler.GetStatistic(statIdThread3Loop) != nullptr);
+        EXPECT_EQ(profiler.GetStatistic(statIdThread3Loop)->GetNumSamples(), iter_count);
+
+        profiler.LogAndResetStats("3_Threads_StatisticalProfilerProxy");
+
+        //Clean Up
+        proxy->ActivateProfiler(AZ::Debug::ProfileCategory::Terrain, false);
+    }
+
+}//namespace UnitTest
diff --git a/Code/Framework/AzCore/Tests/Statistics.cpp b/Code/Framework/AzCore/Tests/Statistics.cpp
new file mode 100644
index 0000000000..941c2eff0b
--- /dev/null
+++ b/Code/Framework/AzCore/Tests/Statistics.cpp
@@ -0,0 +1,263 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+#include <AzCore/UnitTest/TestTypes.h>
+#include <AzCore/UnitTest/UnitTest.h>
+#include <AzTest/AzTest.h>
+
+#include <AzCore/Math/Crc.h>
+#include <AzCore/std/string/string.h>
+
+#include <AzCore/Statistics/StatisticsManager.h>
+
+using namespace AZ;
+using namespace Debug;
+
+namespace UnitTest
+{
+    class StatisticsTest
+        : public AllocatorsFixture
+    {
+    public:
+        StatisticsTest()
+        {
+        }
+
+        void SetUp() override
+        {
+            AllocatorsFixture::SetUp();
+
+            m_dataSamples = AZStd::make_unique<AZStd::vector<u32>>();
+            const u32 numSamples = 100;
+            m_dataSamples->set_capacity(numSamples);
+            for (u32 i = 0; i < numSamples; ++i)
+            {
+                m_dataSamples->push_back(i);
+            }
+        }
+
+        ~StatisticsTest()
+        {
+        }
+
+        void TearDown() override
+        {
+            // clearing up memory
+            m_dataSamples = nullptr;
+
+            AllocatorsFixture::TearDown();
+        }
+
+    protected:
+        AZStd::unique_ptr<AZStd::vector<u32>> m_dataSamples;
+    }; //class StatisticsTest
+
+    TEST_F(StatisticsTest, RunningStatistic_ProcessAnArrayOfNumbers_GetExpectedStatisticalData)
+    {
+        Statistics::RunningStatistic runningStat;
+
+        ASSERT_TRUE(m_dataSamples.get() != nullptr);
+        const AZStd::vector<u32>& dataSamples = *m_dataSamples;
+        for (u32 sample : dataSamples)
+        {
+            runningStat.PushSample(sample);
+        }
+
+        EXPECT_EQ(runningStat.GetNumSamples(), dataSamples.size());
+        EXPECT_EQ(runningStat.GetMostRecentSample(), dataSamples.back());
+        EXPECT_EQ(runningStat.GetMinimum(), dataSamples[0]);
+        EXPECT_EQ(runningStat.GetMaximum(), dataSamples.back());
+        EXPECT_NEAR(runningStat.GetAverage(), 49.5, 0.001);
+        EXPECT_NEAR(runningStat.GetVariance(), 841.666, 0.001);
+        EXPECT_NEAR(runningStat.GetStdev(), 29.011, 0.001);
+        EXPECT_NEAR(runningStat.GetVariance(Statistics::VarianceType::P), 833.25, 0.001);
+        EXPECT_NEAR(runningStat.GetStdev(Statistics::VarianceType::P), 28.866, 0.001);
+
+        //Reset the stat object.
+        runningStat.Reset();
+        EXPECT_EQ(runningStat.GetNumSamples(), 0);
+        EXPECT_EQ(runningStat.GetAverage(), 0.0);
+        EXPECT_EQ(runningStat.GetStdev(), 0.0);
+    }
+
+
+    TEST_F(StatisticsTest, StatisticsManager_AddAndRemoveStatisticistics_CollectionIntegrityIsCorrect)
+    {
+        Statistics::StatisticsManager<> statsManager;
+        AZStd::string statName0("stat0");
+        AZStd::string statName1("stat1");
+        AZStd::string statName2("stat2");
+        AZStd::string statName3("stat3");
+        EXPECT_TRUE(statsManager.AddStatistic(statName0, statName0, ""));
+        EXPECT_TRUE(statsManager.AddStatistic(statName1, statName1, ""));
+        EXPECT_TRUE(statsManager.AddStatistic(statName2, statName2, ""));
+        EXPECT_TRUE(statsManager.AddStatistic(statName3, statName3, ""));
+
+        //Validate the number of running statistics object we have so far.
+        {
+            AZStd::vector<Statistics::NamedRunningStatistic*> allStats;
+            statsManager.GetAllStatistics(allStats);
+            EXPECT_TRUE(allStats.size() == 4);
+        }
+
+        //Try to add an Stat that already exist. expect to fail.
+        EXPECT_EQ(statsManager.AddStatistic(statName1), nullptr);
+
+        //Remove stat1.
+        statsManager.RemoveStatistic(statName1);
+        //Validate the number of running statistics object we have so far.
+        {
+            AZStd::vector<Statistics::NamedRunningStatistic*> allStats;
+            statsManager.GetAllStatistics(allStats);
+            EXPECT_TRUE(allStats.size() == 3);
+        }
+
+        //Add stat1 again, expect to pass.
+        EXPECT_TRUE(statsManager.AddStatistic(statName1));
+
+        //Get a pointer to stat2.
+        Statistics::NamedRunningStatistic* stat2 = statsManager.GetStatistic(statName2);
+        ASSERT_TRUE(stat2 != nullptr);
+        EXPECT_EQ(stat2->GetName(), statName2);
+    }
+
+    TEST_F(StatisticsTest, StatisticsManager_DistributeSamplesAcrossStatistics_StatisticsAreCorrect)
+    {
+        Statistics::StatisticsManager<> statsManager;
+        AZStd::string statName0("stat0");
+        AZStd::string statName1("stat1");
+        AZStd::string statName2("stat2");
+        AZStd::string statName3("stat3");
+
+        EXPECT_TRUE(statsManager.AddStatistic(statName3));
+        EXPECT_TRUE(statsManager.AddStatistic(statName0));
+        EXPECT_TRUE(statsManager.AddStatistic(statName2));
+        EXPECT_TRUE(statsManager.AddStatistic(statName1));
+
+        //Distribute the 100 samples of data evenly across the 4 running statistics.
+        ASSERT_TRUE(m_dataSamples.get() != nullptr);
+        const AZStd::vector<u32>& dataSamples = *m_dataSamples;
+        const size_t numSamples = dataSamples.size();
+        const size_t numSamplesPerStat = numSamples / 4;
+        size_t sampleIndex = 0;
+        size_t nextStopIndex = numSamplesPerStat;
+        while (sampleIndex < nextStopIndex)
+        {
+            statsManager.PushSampleForStatistic(statName0, dataSamples[sampleIndex]);
+            sampleIndex++;
+        }
+        nextStopIndex += numSamplesPerStat;
+        while (sampleIndex < nextStopIndex)
+        {
+            statsManager.PushSampleForStatistic(statName1, dataSamples[sampleIndex]);
+            sampleIndex++;
+        }
+        nextStopIndex += numSamplesPerStat;
+        while (sampleIndex < nextStopIndex)
+        {
+            statsManager.PushSampleForStatistic(statName2, dataSamples[sampleIndex]);
+            sampleIndex++;
+        }
+        nextStopIndex += numSamplesPerStat;
+        while (sampleIndex < nextStopIndex)
+        {
+            statsManager.PushSampleForStatistic(statName3, dataSamples[sampleIndex]);
+            sampleIndex++;
+        }
+
+        EXPECT_NEAR(statsManager.GetStatistic(statName0)->GetAverage(), 12.0, 0.001);
+        EXPECT_NEAR(statsManager.GetStatistic(statName1)->GetAverage(), 37.0, 0.001);
+        EXPECT_NEAR(statsManager.GetStatistic(statName2)->GetAverage(), 62.0, 0.001);
+        EXPECT_NEAR(statsManager.GetStatistic(statName3)->GetAverage(), 87.0, 0.001);
+
+        EXPECT_NEAR(statsManager.GetStatistic(statName0)->GetStdev(), 7.359, 0.001);
+        EXPECT_NEAR(statsManager.GetStatistic(statName1)->GetStdev(), 7.359, 0.001);
+        EXPECT_NEAR(statsManager.GetStatistic(statName2)->GetStdev(), 7.359, 0.001);
+        EXPECT_NEAR(statsManager.GetStatistic(statName3)->GetStdev(), 7.359, 0.001);
+
+        //Reset one of the stats.
+        statsManager.ResetStatistic(statName2);
+        EXPECT_EQ(statsManager.GetStatistic(statName2)->GetAverage(), 0.0);
+        //Reset all of the stats.
+        statsManager.ResetAllStatistics();
+        EXPECT_EQ(statsManager.GetStatistic(statName0)->GetNumSamples(), 0);
+        EXPECT_EQ(statsManager.GetStatistic(statName1)->GetNumSamples(), 0);
+        EXPECT_EQ(statsManager.GetStatistic(statName2)->GetNumSamples(), 0);
+        EXPECT_EQ(statsManager.GetStatistic(statName3)->GetNumSamples(), 0);
+    }
+
+    TEST_F(StatisticsTest, StatisticsManagerCrc32_DistributeSamplesAcrossStatistics_StatisticsAreCorrect)
+    {
+        Statistics::StatisticsManager<AZ::Crc32> statsManager;
+        AZ::Crc32 statName0 = AZ_CRC("stat0", 0xb8927780);
+        AZ::Crc32 statName1 = AZ_CRC("stat1", 0xcf954716);
+        AZ::Crc32 statName2 = AZ_CRC("stat2", 0x569c16ac);
+        AZ::Crc32 statName3 = AZ_CRC("stat3", 0x219b263a);
+
+        EXPECT_TRUE(statsManager.AddStatistic(statName3) != nullptr);
+        EXPECT_TRUE(statsManager.AddStatistic(statName0) != nullptr);
+        EXPECT_TRUE(statsManager.AddStatistic(statName2) != nullptr);
+        EXPECT_TRUE(statsManager.AddStatistic(statName1) != nullptr);
+
+        EXPECT_TRUE(statsManager.GetStatistic(statName3) != nullptr);
+        EXPECT_TRUE(statsManager.GetStatistic(statName0) != nullptr);
+        EXPECT_TRUE(statsManager.GetStatistic(statName1) != nullptr);
+        EXPECT_TRUE(statsManager.GetStatistic(statName2) != nullptr);
+
+        //Distribute the 100 samples of data evenly across the 4 running statistics.
+        ASSERT_TRUE(m_dataSamples.get() != nullptr);
+        const AZStd::vector<u32>& dataSamples = *m_dataSamples;
+        const size_t numSamples = dataSamples.size();
+        const size_t numSamplesPerStat = numSamples / 4;
+        size_t sampleIndex = 0;
+        size_t nextStopIndex = numSamplesPerStat;
+        while (sampleIndex < nextStopIndex)
+        {
+            statsManager.PushSampleForStatistic(statName0, dataSamples[sampleIndex]);
+            sampleIndex++;
+        }
+        nextStopIndex += numSamplesPerStat;
+        while (sampleIndex < nextStopIndex)
+        {
+            statsManager.PushSampleForStatistic(statName1, dataSamples[sampleIndex]);
+            sampleIndex++;
+        }
+        nextStopIndex += numSamplesPerStat;
+        while (sampleIndex < nextStopIndex)
+        {
+            statsManager.PushSampleForStatistic(statName2, dataSamples[sampleIndex]);
+            sampleIndex++;
+        }
+        nextStopIndex += numSamplesPerStat;
+        while (sampleIndex < nextStopIndex)
+        {
+            statsManager.PushSampleForStatistic(statName3, dataSamples[sampleIndex]);
+            sampleIndex++;
+        }
+
+        EXPECT_NEAR(statsManager.GetStatistic(statName0)->GetAverage(), 12.0, 0.001);
+        EXPECT_NEAR(statsManager.GetStatistic(statName1)->GetAverage(), 37.0, 0.001);
+        EXPECT_NEAR(statsManager.GetStatistic(statName2)->GetAverage(), 62.0, 0.001);
+        EXPECT_NEAR(statsManager.GetStatistic(statName3)->GetAverage(), 87.0, 0.001);
+
+        EXPECT_NEAR(statsManager.GetStatistic(statName0)->GetStdev(), 7.359, 0.001);
+        EXPECT_NEAR(statsManager.GetStatistic(statName1)->GetStdev(), 7.359, 0.001);
+        EXPECT_NEAR(statsManager.GetStatistic(statName2)->GetStdev(), 7.359, 0.001);
+        EXPECT_NEAR(statsManager.GetStatistic(statName3)->GetStdev(), 7.359, 0.001);
+
+        //Reset one of the stats.
+        statsManager.ResetStatistic(statName2);
+        EXPECT_EQ(statsManager.GetStatistic(statName2)->GetAverage(), 0.0);
+        //Reset all of the stats.
+        statsManager.ResetAllStatistics();
+        EXPECT_EQ(statsManager.GetStatistic(statName0)->GetNumSamples(), 0);
+        EXPECT_EQ(statsManager.GetStatistic(statName1)->GetNumSamples(), 0);
+        EXPECT_EQ(statsManager.GetStatistic(statName2)->GetNumSamples(), 0);
+        EXPECT_EQ(statsManager.GetStatistic(statName3)->GetNumSamples(), 0);
+    }
+
+}//namespace UnitTest
diff --git a/Code/Framework/AzCore/Tests/TimeDataStatistics.cpp b/Code/Framework/AzCore/Tests/TimeDataStatistics.cpp
new file mode 100644
index 0000000000..50856b1df8
--- /dev/null
+++ b/Code/Framework/AzCore/Tests/TimeDataStatistics.cpp
@@ -0,0 +1,207 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+#include <AzCore/UnitTest/TestTypes.h>
+#include <AzCore/UnitTest/UnitTest.h>
+#include <AzTest/AzTest.h>
+
+#include <AzCore/std/string/string.h>
+#include <AzCore/std/parallel/thread.h>
+
+#include <AzCore/Statistics/TimeDataStatisticsManager.h>
+
+#include <AzCore/Component/Component.h>
+#include <AzCore/Component/ComponentApplication.h>
+#include <AzCore/Component/TickBus.h>
+#include <AzCore/Component/EntityUtils.h>
+#include <AzCore/Debug/FrameProfilerBus.h>
+#include <AzCore/Debug/FrameProfilerComponent.h>
+
+using namespace AZ;
+using namespace Debug;
+
+namespace UnitTest
+{
+    /**
+     * Validate functionality of the convenience class TimeDataStatisticsManager.
+     * It is a specialized version of RunningStatisticsManager that works with Timer type
+     * of registers that can be captured with the FrameProfilerBus::OnFrameProfilerData()
+     */
+    class TimeDataStatisticsManagerTest
+        : public AllocatorsFixture
+        , public FrameProfilerBus::Handler
+    {
+        static constexpr const char* PARENT_TIMER_STAT = "ParentStat";
+        static constexpr const char* CHILD_TIMER_STAT0 = "ChildStat0";
+        static constexpr const char* CHILD_TIMER_STAT1 = "ChildStat1";
+
+    public:
+        TimeDataStatisticsManagerTest()
+            : AllocatorsFixture()
+        {
+        }
+
+        void SetUp() override
+        {
+            AllocatorsFixture::SetUp();
+            m_statsManager = AZStd::make_unique<Statistics::TimeDataStatisticsManager>();
+        }
+
+        void TearDown() override
+        {
+            m_statsManager = nullptr;
+            AllocatorsFixture::TearDown();
+        }
+
+        //////////////////////////////////////////////////////////////////////////
+        // FrameProfilerBus
+        virtual void OnFrameProfilerData(const FrameProfiler::ThreadDataArray& data)
+        {
+            for (size_t iThread = 0; iThread < data.size(); ++iThread)
+            {
+                const FrameProfiler::ThreadData& td = data[iThread];
+                FrameProfiler::ThreadData::RegistersMap::const_iterator regIt = td.m_registers.begin();
+                for (; regIt != td.m_registers.end(); ++regIt)
+                {
+                    const FrameProfiler::RegisterData& rd = regIt->second;
+                    u32 unitTestCrc = AZ_CRC("UnitTest", 0x8089cea8);
+                    if (unitTestCrc != rd.m_systemId)
+                    {
+                        continue; //Not for us.
+                    }
+                    ASSERT_EQ(ProfilerRegister::PRT_TIME, rd.m_type);
+                    const FrameProfiler::FrameData& fd = rd.m_frames.back();
+                    m_statsManager->PushTimeDataSample(rd.m_name, fd.m_timeData);
+                }
+            }
+        }
+        //////////////////////////////////////////////////////////////////////////
+
+        int ChildFunction0(int numIterations, int sleepTimeMilliseconds)
+        {
+            AZ_PROFILE_TIMER("UnitTest", CHILD_TIMER_STAT0);
+            AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(sleepTimeMilliseconds));
+            int result = 5;
+            for (int i = 0; i < numIterations; ++i)
+            {
+                result += i % 3;
+            }
+            return result;
+        }
+
+        int ChildFunction1(int numIterations, int sleepTimeMilliseconds)
+        {
+            AZ_PROFILE_TIMER("UnitTest", CHILD_TIMER_STAT1);
+            AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(sleepTimeMilliseconds));
+            int result = 5;
+            for (int i = 0; i < numIterations; ++i)
+            {
+                result += i % 3;
+            }
+            return result;
+        }
+
+        int ParentFunction(int numIterations, int sleepTimeMilliseconds)
+        {
+            AZ_PROFILE_TIMER("UnitTest", PARENT_TIMER_STAT);
+            AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(sleepTimeMilliseconds));
+            int result = 0;
+            result += ChildFunction0(numIterations, sleepTimeMilliseconds);
+            result += ChildFunction1(numIterations, sleepTimeMilliseconds);
+            return result;
+        }
+
+        void run()
+        {
+           Debug::FrameProfilerBus::Handler::BusConnect();
+           
+           ComponentApplication app;
+           ComponentApplication::Descriptor desc;
+           desc.m_useExistingAllocator = true;
+           desc.m_enableDrilling = false;  // we already created a memory driller for the test (AllocatorsFixture)
+           ComponentApplication::StartupParameters startupParams;
+           startupParams.m_allocator = &AllocatorInstance<SystemAllocator>::Get();
+           Entity* systemEntity = app.Create(desc, startupParams);
+           systemEntity->CreateComponent<FrameProfilerComponent>();
+           
+           systemEntity->Init();
+           systemEntity->Activate(); // start frame component
+           
+           const int sleepTimeAllFuncsMillis = 1;
+           const int numIterations = 10;
+           for (int iterationCounter = 0; iterationCounter < numIterations; ++iterationCounter)
+           {
+               ParentFunction(numIterations, sleepTimeAllFuncsMillis);
+               //Collect all samples.
+               app.Tick();
+           }
+
+           //Verify we have three running stats.
+           {
+               AZStd::vector<Statistics::NamedRunningStatistic*> allStats;
+               m_statsManager->GetAllStatistics(allStats);
+               EXPECT_EQ(allStats.size(), 3);
+           }
+
+           AZStd::string parentStatName(PARENT_TIMER_STAT);
+           AZStd::string child0StatName(CHILD_TIMER_STAT0);
+           AZStd::string child1StatName(CHILD_TIMER_STAT1);
+           ASSERT_TRUE(m_statsManager->GetStatistic(parentStatName) != nullptr);
+           ASSERT_TRUE(m_statsManager->GetStatistic(child0StatName) != nullptr);
+           ASSERT_TRUE(m_statsManager->GetStatistic(child1StatName) != nullptr);
+           
+           EXPECT_EQ(m_statsManager->GetStatistic(parentStatName)->GetNumSamples(), numIterations);
+           EXPECT_EQ(m_statsManager->GetStatistic(child0StatName)->GetNumSamples(), numIterations);
+           EXPECT_EQ(m_statsManager->GetStatistic(child1StatName)->GetNumSamples(), numIterations);
+
+           const double minimumExpectDurationOfChildFunctionMicros = 1;
+           const double minimumExpectDurationOfParentFunctionMicros = 1;
+
+           EXPECT_GE(m_statsManager->GetStatistic(parentStatName)->GetMinimum(), minimumExpectDurationOfParentFunctionMicros);
+           EXPECT_GE(m_statsManager->GetStatistic(parentStatName)->GetAverage(), minimumExpectDurationOfParentFunctionMicros);
+           EXPECT_GE(m_statsManager->GetStatistic(parentStatName)->GetMaximum(), minimumExpectDurationOfParentFunctionMicros);
+
+           EXPECT_GE(m_statsManager->GetStatistic(child0StatName)->GetMinimum(), minimumExpectDurationOfChildFunctionMicros);
+           EXPECT_GE(m_statsManager->GetStatistic(child0StatName)->GetAverage(), minimumExpectDurationOfChildFunctionMicros);
+           EXPECT_GE(m_statsManager->GetStatistic(child0StatName)->GetMaximum(), minimumExpectDurationOfChildFunctionMicros);
+                                                                                                                      
+           EXPECT_GE(m_statsManager->GetStatistic(child1StatName)->GetMinimum(), minimumExpectDurationOfChildFunctionMicros);
+           EXPECT_GE(m_statsManager->GetStatistic(child1StatName)->GetAverage(), minimumExpectDurationOfChildFunctionMicros);
+           EXPECT_GE(m_statsManager->GetStatistic(child1StatName)->GetMaximum(), minimumExpectDurationOfChildFunctionMicros);
+
+           //Let's validate TimeDataStatisticsManager::RemoveStatistics()
+           m_statsManager->RemoveStatistic(child1StatName);
+           ASSERT_TRUE(m_statsManager->GetStatistic(parentStatName) != nullptr);
+           ASSERT_TRUE(m_statsManager->GetStatistic(child0StatName) != nullptr);
+           EXPECT_EQ(m_statsManager->GetStatistic(child1StatName), nullptr);
+
+           //Let's store the sample count for both parentStatName and child0StatName.
+           const AZ::u64 numSamplesParent = m_statsManager->GetStatistic(parentStatName)->GetNumSamples();
+           const AZ::u64 numSamplesChild0 = m_statsManager->GetStatistic(child0StatName)->GetNumSamples();
+
+           //Let's call child1 function again and call app.Tick(). child1StatName should be readded to m_statsManager.
+           ChildFunction1(numIterations, sleepTimeAllFuncsMillis);
+           app.Tick();
+           ASSERT_TRUE(m_statsManager->GetStatistic(child1StatName) != nullptr);
+           EXPECT_EQ(m_statsManager->GetStatistic(parentStatName)->GetNumSamples(), numSamplesParent);
+           EXPECT_EQ(m_statsManager->GetStatistic(child0StatName)->GetNumSamples(), numSamplesChild0);
+           EXPECT_EQ(m_statsManager->GetStatistic(child1StatName)->GetNumSamples(), 1);
+
+           Debug::FrameProfilerBus::Handler::BusDisconnect();
+           app.Destroy();
+        }
+
+        AZStd::unique_ptr<Statistics::TimeDataStatisticsManager> m_statsManager;
+    };//class TimeDataStatisticsManagerTest
+
+    TEST_F(TimeDataStatisticsManagerTest, Test)
+    {
+        run();
+    }
+    //End of all Tests of TimeDataStatisticsManagerTest
+
+}//namespace UnitTest
diff --git a/Code/Framework/AzCore/Tests/azcoretests_files.cmake b/Code/Framework/AzCore/Tests/azcoretests_files.cmake
index 7833cf97bb..911eaa7b10 100644
--- a/Code/Framework/AzCore/Tests/azcoretests_files.cmake
+++ b/Code/Framework/AzCore/Tests/azcoretests_files.cmake
@@ -60,11 +60,13 @@ set(FILES
     SerializeContextFixture.h
     Slice.cpp
     State.cpp
+    Statistics.cpp
     StreamerTests.cpp
     StringFunc.cpp
     SystemFile.cpp
     TaskTests.cpp
     TickBusTest.cpp
+    TimeDataStatistics.cpp
     UUIDTests.cpp
     XML.cpp
     Debug/AssetTracking.cpp
diff --git a/Gems/Atom/Utils/Code/Include/Atom/Utils/StableDynamicArray.h b/Gems/Atom/Utils/Code/Include/Atom/Utils/StableDynamicArray.h
index e73f641b96..454a6d4086 100644
--- a/Gems/Atom/Utils/Code/Include/Atom/Utils/StableDynamicArray.h
+++ b/Gems/Atom/Utils/Code/Include/Atom/Utils/StableDynamicArray.h
@@ -130,7 +130,6 @@ namespace AZ
     template<typename T, size_t ElementsPerPage, class Allocator>
     struct StableDynamicArray<T, ElementsPerPage, Allocator>::Page
     {
-        static constexpr size_t PageSize = ElementsPerPage * sizeof(T);
         static constexpr size_t InvalidPage = -1;
         static constexpr uint64_t FullBits = 0xFFFFFFFFFFFFFFFFull;
         static constexpr size_t NumUint64_t = ElementsPerPage / 64;

From ec6e9407f6cd1a1c8f535785def37b33e2dd80a3 Mon Sep 17 00:00:00 2001
From: Jeremy Ong <jcong@amazon.com>
Date: Wed, 18 Aug 2021 17:20:27 -0600
Subject: [PATCH 31/37] Remove RAD (pending future interface for external
 profiler registration)

Signed-off-by: Jeremy Ong <jcong@amazon.com>
---
 .../AzCore/Component/ComponentApplication.h   |   1 -
 .../AzCore/AzCore/Debug/EventTrace.h          |  17 +-
 .../AzCore/AzCore/Debug/ProfileModuleInit.cpp |  53 ---
 .../AzCore/AzCore/Debug/ProfileModuleInit.h   |  36 --
 Code/Framework/AzCore/AzCore/Debug/Profiler.h |   6 -
 Code/Framework/AzCore/AzCore/Module/Module.h  |   4 -
 .../AzCore/Script/ScriptSystemComponent.cpp   |   8 -
 .../Statistics/StatisticalProfilerProxy.h     |   4 +-
 .../AzCore/AzCore/azcore_files.cmake          |   2 -
 Code/Framework/AzCore/CMakeLists.txt          |  11 -
 .../profile_telemetry_platform_android.cmake  |   4 -
 .../Common/RadTelemetry/ProfileTelemetry.h    | 143 --------
 .../Common/RadTelemetry/ProfileTelemetryBus.h |  49 ---
 .../Mac/profile_telemetry_platform_mac.cmake  |   4 -
 .../profile_telemetry_platform_windows.cmake  |   4 -
 .../iOS/profile_telemetry_platform_ios.cmake  |   4 -
 .../AzCore/Tests/TimeDataStatistics.cpp       |  11 +-
 Code/Legacy/CryCommon/ISystem.h               |  11 -
 Code/Legacy/CryCommon/ProjectDefines.h        |   2 +-
 Code/Legacy/CryCommon/platform_impl.cpp       |   2 -
 Gems/RADTelemetry/CMakeLists.txt              |   9 -
 Gems/RADTelemetry/Code/CMakeLists.txt         |  47 ---
 .../Android/RADTelemetry_Traits_Platform.h    |  10 -
 .../Android/platform_android_files.cmake      |  11 -
 .../Linux/RADTelemetry_Traits_Platform.h      |  10 -
 .../Platform/Linux/platform_linux_files.cmake |  11 -
 .../Mac/RADTelemetry_Traits_Platform.h        |  10 -
 .../Platform/Mac/platform_mac_files.cmake     |  11 -
 .../Windows/RADTelemetry_Traits_Platform.h    |  10 -
 .../Windows/platform_windows_files.cmake      |  11 -
 .../iOS/RADTelemetry_Traits_Platform.h        |  10 -
 .../Platform/iOS/platform_ios_files.cmake     |  11 -
 .../Code/Source/ProfileTelemetryComponent.cpp | 344 ------------------
 .../Code/Source/ProfileTelemetryComponent.h   | 103 ------
 .../Code/Source/RADTelemetryModule.cpp        | 132 -------
 .../Code/radtelemetry_files.cmake             |  12 -
 .../Code/radtelemetry_shared_files.cmake      |  11 -
 Gems/RADTelemetry/gem.json                    |  13 -
 Gems/RADTelemetry/preview.png                 |   3 -
 .../Android/RadTelemetry_android.cmake        |   9 -
 .../Platform/Mac/RadTelemetry_mac.cmake       |  11 -
 .../Windows/RadTelemetry_windows.cmake        |  11 -
 .../Platform/iOS/RadTelemetry_ios.cmake       |   9 -
 engine.json                                   |   1 -
 44 files changed, 12 insertions(+), 1184 deletions(-)
 delete mode 100644 Code/Framework/AzCore/AzCore/Debug/ProfileModuleInit.cpp
 delete mode 100644 Code/Framework/AzCore/AzCore/Debug/ProfileModuleInit.h
 delete mode 100644 Code/Framework/AzCore/Platform/Common/RadTelemetry/ProfileTelemetry.h
 delete mode 100644 Code/Framework/AzCore/Platform/Common/RadTelemetry/ProfileTelemetryBus.h
 delete mode 100644 Gems/RADTelemetry/CMakeLists.txt
 delete mode 100644 Gems/RADTelemetry/Code/CMakeLists.txt
 delete mode 100644 Gems/RADTelemetry/Code/Source/Platform/Android/RADTelemetry_Traits_Platform.h
 delete mode 100644 Gems/RADTelemetry/Code/Source/Platform/Android/platform_android_files.cmake
 delete mode 100644 Gems/RADTelemetry/Code/Source/Platform/Linux/RADTelemetry_Traits_Platform.h
 delete mode 100644 Gems/RADTelemetry/Code/Source/Platform/Linux/platform_linux_files.cmake
 delete mode 100644 Gems/RADTelemetry/Code/Source/Platform/Mac/RADTelemetry_Traits_Platform.h
 delete mode 100644 Gems/RADTelemetry/Code/Source/Platform/Mac/platform_mac_files.cmake
 delete mode 100644 Gems/RADTelemetry/Code/Source/Platform/Windows/RADTelemetry_Traits_Platform.h
 delete mode 100644 Gems/RADTelemetry/Code/Source/Platform/Windows/platform_windows_files.cmake
 delete mode 100644 Gems/RADTelemetry/Code/Source/Platform/iOS/RADTelemetry_Traits_Platform.h
 delete mode 100644 Gems/RADTelemetry/Code/Source/Platform/iOS/platform_ios_files.cmake
 delete mode 100644 Gems/RADTelemetry/Code/Source/ProfileTelemetryComponent.cpp
 delete mode 100644 Gems/RADTelemetry/Code/Source/ProfileTelemetryComponent.h
 delete mode 100644 Gems/RADTelemetry/Code/Source/RADTelemetryModule.cpp
 delete mode 100644 Gems/RADTelemetry/Code/radtelemetry_files.cmake
 delete mode 100644 Gems/RADTelemetry/Code/radtelemetry_shared_files.cmake
 delete mode 100644 Gems/RADTelemetry/gem.json
 delete mode 100644 Gems/RADTelemetry/preview.png
 delete mode 100644 cmake/3rdParty/Platform/Android/RadTelemetry_android.cmake
 delete mode 100644 cmake/3rdParty/Platform/Mac/RadTelemetry_mac.cmake
 delete mode 100644 cmake/3rdParty/Platform/Windows/RadTelemetry_windows.cmake
 delete mode 100644 cmake/3rdParty/Platform/iOS/RadTelemetry_ios.cmake

diff --git a/Code/Framework/AzCore/AzCore/Component/ComponentApplication.h b/Code/Framework/AzCore/AzCore/Component/ComponentApplication.h
index 278e911455..d2da86c368 100644
--- a/Code/Framework/AzCore/AzCore/Component/ComponentApplication.h
+++ b/Code/Framework/AzCore/AzCore/Component/ComponentApplication.h
@@ -11,7 +11,6 @@
 #include <AzCore/Component/Component.h>
 #include <AzCore/Component/Entity.h>
 #include <AzCore/Component/TickBus.h>
-#include <AzCore/Debug/ProfileModuleInit.h>
 #include <AzCore/Memory/AllocationRecords.h>
 #include <AzCore/Memory/OSAllocator.h>
 #include <AzCore/Module/DynamicModuleHandle.h>
diff --git a/Code/Framework/AzCore/AzCore/Debug/EventTrace.h b/Code/Framework/AzCore/AzCore/Debug/EventTrace.h
index 8d096707ba..1bc7ee20a6 100644
--- a/Code/Framework/AzCore/AzCore/Debug/EventTrace.h
+++ b/Code/Framework/AzCore/AzCore/Debug/EventTrace.h
@@ -38,17 +38,6 @@ namespace AZ
     }
 }
 
-#ifdef AZ_PROFILE_TELEMETRY
-#   define AZ_TRACE_METHOD_NAME_CATEGORY(name, category) AZ::Debug::EventTrace::ScopedSlice AZ_JOIN(ScopedSlice__, __LINE__)(name, category);
-#   define AZ_TRACE_METHOD_NAME(name) \
-        AZ_TRACE_METHOD_NAME_CATEGORY(name, "") \
-        AZ_PROFILE_SCOPE(AzTrace, name)
-
-#   define AZ_TRACE_METHOD() \
-        AZ_TRACE_METHOD_NAME_CATEGORY(AZ_FUNCTION_SIGNATURE, "") \
-        AZ_PROFILE_FUNCTION(AzTrace)
-#else
-#   define AZ_TRACE_METHOD_NAME_CATEGORY(name, category)
-#   define AZ_TRACE_METHOD_NAME(name) AZ_TRACE_METHOD_NAME_CATEGORY(name, "")
-#   define AZ_TRACE_METHOD() AZ_TRACE_METHOD_NAME(AZ_FUNCTION_SIGNATURE)
-#endif
+#define AZ_TRACE_METHOD_NAME_CATEGORY(name, category)
+#define AZ_TRACE_METHOD_NAME(name) AZ_TRACE_METHOD_NAME_CATEGORY(name, "")
+#define AZ_TRACE_METHOD() AZ_TRACE_METHOD_NAME(AZ_FUNCTION_SIGNATURE)
diff --git a/Code/Framework/AzCore/AzCore/Debug/ProfileModuleInit.cpp b/Code/Framework/AzCore/AzCore/Debug/ProfileModuleInit.cpp
deleted file mode 100644
index 9dda1f7656..0000000000
--- a/Code/Framework/AzCore/AzCore/Debug/ProfileModuleInit.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include <AzCore/Debug/ProfileModuleInit.h>
-
-#ifdef AZ_PROFILE_TELEMETRY
-#   include <RADTelemetry/ProfileTelemetryBus.h>
-    // Define the per-module RAD Telemetry instance pointer
-    struct tm_api;
-    tm_api* g_radTmApi;
-#endif
-
-
-namespace AZ
-{
-    namespace Debug
-    {
-        void ProfileModuleInit()
-        {
-#if defined(AZ_PROFILE_TELEMETRY)
-            {
-                if (!g_radTmApi)
-                {
-                    using namespace RADTelemetry;
-                    ProfileTelemetryRequestBus::BroadcastResult(g_radTmApi, &ProfileTelemetryRequests::GetApiInstance);
-                }
-            }
-#endif
-            // Add additional per-DLL required profiler initialization here
-        }
-
-
-        ProfileModuleInitializer::ProfileModuleInitializer()
-        {
-            ProfilerNotificationBus::Handler::BusConnect();
-        }
-
-        ProfileModuleInitializer::~ProfileModuleInitializer()
-        {
-            ProfilerNotificationBus::Handler::BusDisconnect();
-        }
-
-        void ProfileModuleInitializer::OnProfileSystemInitialized()
-        {
-            ProfileModuleInit();
-        }
-    }
-}
diff --git a/Code/Framework/AzCore/AzCore/Debug/ProfileModuleInit.h b/Code/Framework/AzCore/AzCore/Debug/ProfileModuleInit.h
deleted file mode 100644
index e6666c9747..0000000000
--- a/Code/Framework/AzCore/AzCore/Debug/ProfileModuleInit.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#pragma once
-
-#include <AzCore/Debug/ProfilerBus.h>
-
-namespace AZ
-{
-    namespace Debug
-    {
-        //! Perform any required per-module initialization of the current profiler
-        void ProfileModuleInit();
-
-
-        /*!
-        * ProfileModuleInitializer
-        * Helper class that calls ProfileModuleInit when OnProfileSystemInitialized is fired.
-        */
-        class ProfileModuleInitializer
-            : private AZ::Debug::ProfilerNotificationBus::Handler
-        {
-        public:
-            ProfileModuleInitializer();
-            ~ProfileModuleInitializer() override;
-
-        private:
-            void OnProfileSystemInitialized() override;
-        };
-    }
-}
diff --git a/Code/Framework/AzCore/AzCore/Debug/Profiler.h b/Code/Framework/AzCore/AzCore/Debug/Profiler.h
index 5cb6142ebf..1d932031ef 100644
--- a/Code/Framework/AzCore/AzCore/Debug/Profiler.h
+++ b/Code/Framework/AzCore/AzCore/Debug/Profiler.h
@@ -15,10 +15,6 @@
 #include <WinPixEventRuntime/pix3.h>
 #endif
 
-#ifdef AZ_PROFILE_TELEMETRY
-#   include <RADTelemetry/ProfileTelemetry.h>
-#endif
-
 #if defined(AZ_PROFILER_MACRO_DISABLE) // by default we never disable the profiler registers as their overhead should be minimal, you can still do that for your code though.
 #   define AZ_PROFILE_SCOPE(...)
 #   define AZ_PROFILE_FUNCTION(...)
@@ -38,7 +34,6 @@
 #endif // AZ_PROFILER_MACRO_DISABLE
 
 #ifndef AZ_PROFILE_INTERVAL_START
-// No other profiler has defined the performance markers AZ_PROFILE_INTERVAL_START/END, fallback to a Driller implementation (currently empty)
 #   define AZ_PROFILE_INTERVAL_START(...)
 #   define AZ_PROFILE_INTERVAL_START_COLORED(...)
 #   define AZ_PROFILE_INTERVAL_END(...)
@@ -46,7 +41,6 @@
 #endif
 
 #ifndef AZ_PROFILE_DATAPOINT
-// No other profiler has defined the performance markers AZ_PROFILE_DATAPOINT, fallback to a Driller implementation (currently empty)
 #   define AZ_PROFILE_DATAPOINT(...)
 #   define AZ_PROFILE_DATAPOINT_PERCENT(...)
 #endif
diff --git a/Code/Framework/AzCore/AzCore/Module/Module.h b/Code/Framework/AzCore/AzCore/Module/Module.h
index 2c87b4f0fb..9606342cf7 100644
--- a/Code/Framework/AzCore/AzCore/Module/Module.h
+++ b/Code/Framework/AzCore/AzCore/Module/Module.h
@@ -9,7 +9,6 @@
 #define AZCORE_MODULE_INCLUDE_H 1
 
 #include <AzCore/Component/Component.h>
-#include <AzCore/Debug/ProfileModuleInit.h>
 #include <AzCore/Memory/SystemAllocator.h>
 #include <AzCore/Module/Environment.h>
 #include <AzCore/Interface/Interface.h>
@@ -78,9 +77,6 @@ namespace AZ
 
     protected:
         AZStd::list<AZ::ComponentDescriptor*> m_descriptors;
-
-    private:
-        AZ::Debug::ProfileModuleInitializer m_moduleProfilerInit;
     };
 } // namespace AZ
 
diff --git a/Code/Framework/AzCore/AzCore/Script/ScriptSystemComponent.cpp b/Code/Framework/AzCore/AzCore/Script/ScriptSystemComponent.cpp
index 018f9ed15a..a83232c8cb 100644
--- a/Code/Framework/AzCore/AzCore/Script/ScriptSystemComponent.cpp
+++ b/Code/Framework/AzCore/AzCore/Script/ScriptSystemComponent.cpp
@@ -287,14 +287,6 @@ void    ScriptSystemComponent::OnSystemTick()
             contextContainer.m_context->GetDebugContext()->ProcessDebugCommands();
         }
 
-#ifdef AZ_PROFILE_TELEMETRY
-        if (contextContainer.m_context->GetId() == ScriptContextIds::DefaultScriptContextId)
-        {
-            size_t memoryUsageBytes = contextContainer.m_context->GetMemoryUsage();
-            AZ_PROFILE_DATAPOINT(Script, memoryUsageBytes / 1024.0, "Script Memory (KB)");
-        }
-#endif // AZ_PROFILE_TELEMETRY
-
         contextContainer.m_context->GarbageCollectStep(contextContainer.m_garbageCollectorSteps);
     }
 }
diff --git a/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxy.h b/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxy.h
index 5ea69b205c..33d835076f 100644
--- a/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxy.h
+++ b/Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxy.h
@@ -17,7 +17,7 @@
 #include <AzCore/Debug/Profiler.h>
 
 
-#if !defined(AZ_PROFILE_TELEMETRY) && defined(AZ_STATISTICAL_PROFILING_ENABLED)
+#if defined(AZ_STATISTICAL_PROFILING_ENABLED)
 
 #if defined(AZ_PROFILE_SCOPE)
 #undef AZ_PROFILE_SCOPE
@@ -27,7 +27,7 @@
     static const AZStd::string AZ_JOIN(blockName, __LINE__)(scopeNameId); \
     AZ::Statistics::StatisticalProfilerProxy::TimedScope AZ_JOIN(scope, __LINE__)(profiler, AZ_JOIN(blockName, __LINE__));
 
-#endif //#if !defined(AZ_PROFILE_TELEMETRY)
+#endif //#if defined(AZ_STATISTICAL_PROFILING_ENABLED)
 
 namespace AZ::Statistics
 {
diff --git a/Code/Framework/AzCore/AzCore/azcore_files.cmake b/Code/Framework/AzCore/AzCore/azcore_files.cmake
index 59db0d94fc..d106b5b12f 100644
--- a/Code/Framework/AzCore/AzCore/azcore_files.cmake
+++ b/Code/Framework/AzCore/AzCore/azcore_files.cmake
@@ -100,8 +100,6 @@ set(FILES
     Debug/FrameProfilerComponent.h
     Debug/IEventLogger.h
     Debug/MemoryProfiler.h
-    Debug/ProfileModuleInit.cpp
-    Debug/ProfileModuleInit.h
     Debug/Profiler.cpp
     Debug/Profiler.h
     Debug/ProfilerBus.h
diff --git a/Code/Framework/AzCore/CMakeLists.txt b/Code/Framework/AzCore/CMakeLists.txt
index ab9596e2b2..f764242843 100644
--- a/Code/Framework/AzCore/CMakeLists.txt
+++ b/Code/Framework/AzCore/CMakeLists.txt
@@ -12,13 +12,6 @@
 ly_get_list_relative_pal_filename(pal_dir ${CMAKE_CURRENT_LIST_DIR}/Platform/${PAL_PLATFORM_NAME})
 ly_get_list_relative_pal_filename(common_dir ${CMAKE_CURRENT_LIST_DIR}/Platform/Common)
 
-if(LY_RAD_TELEMETRY_ENABLED)
-    set(AZ_CORE_RADTELEMETRY_FILES ${common_dir}/azcore_profile_telemetry_files.cmake)
-    set(AZ_CORE_RADTELEMETRY_PLATFORM_INCLUDES ${pal_dir}/profile_telemetry_platform_${PAL_PLATFORM_NAME_LOWERCASE}.cmake)
-    set(AZ_CORE_RADTELEMETRY_INCLUDE_DIRECTORIES ${common_dir})
-    set(AZ_CORE_RADTELEMETRY_BUILD_DEPENDENCIES 3rdParty::RadTelemetry)
-endif()
-
 if(PAL_TRAIT_PROF_PIX_SUPPORTED AND LY_PIX_ENABLED)
     set(LY_PIX_PATH "${LY_3RDPARTY_PATH}/winpixeventruntime" CACHE PATH "Path to the Windows Pix Event Runtime.")
     set(AZ_CORE_PIX_BUILD_DEPENDENCIES 3rdParty::pix)
@@ -32,16 +25,13 @@ ly_add_target(
         AzCore/azcore_files.cmake
         AzCore/std/azstd_files.cmake
         ${pal_dir}/platform_${PAL_PLATFORM_NAME_LOWERCASE}_files.cmake
-        ${AZ_CORE_RADTELEMETRY_FILES}
     PLATFORM_INCLUDE_FILES
         ${pal_dir}/platform_${PAL_PLATFORM_NAME_LOWERCASE}.cmake
-        ${AZ_CORE_RADTELEMETRY_PLATFORM_INCLUDES}
     INCLUDE_DIRECTORIES
         PUBLIC
             .
             ${pal_dir}
             ${common_dir}
-            ${AZ_CORE_RADTELEMETRY_INCLUDE_DIRECTORIES}
     BUILD_DEPENDENCIES
         PUBLIC
             3rdParty::Lua
@@ -50,7 +40,6 @@ ly_add_target(
             3rdParty::zlib
             3rdParty::zstd
             3rdParty::cityhash
-            ${AZ_CORE_RADTELEMETRY_BUILD_DEPENDENCIES}
             ${AZ_CORE_PIX_BUILD_DEPENDENCIES}
     COMPILE_DEFINITIONS
         PUBLIC
diff --git a/Code/Framework/AzCore/Platform/Android/profile_telemetry_platform_android.cmake b/Code/Framework/AzCore/Platform/Android/profile_telemetry_platform_android.cmake
index df12777586..9ecf9fd999 100644
--- a/Code/Framework/AzCore/Platform/Android/profile_telemetry_platform_android.cmake
+++ b/Code/Framework/AzCore/Platform/Android/profile_telemetry_platform_android.cmake
@@ -11,7 +11,3 @@
 # NOTE: functions in cmake are global, therefore adding functions to this file
 # is being avoided to prevent overriding functions declared in other targets platfrom
 # specific cmake files
-
-if(LY_RAD_TELEMETRY_ENABLED)
-    set(LY_COMPILE_DEFINITIONS PUBLIC AZ_PROFILE_TELEMETRY)
-endif()
diff --git a/Code/Framework/AzCore/Platform/Common/RadTelemetry/ProfileTelemetry.h b/Code/Framework/AzCore/Platform/Common/RadTelemetry/ProfileTelemetry.h
deleted file mode 100644
index 7677c985c6..0000000000
--- a/Code/Framework/AzCore/Platform/Common/RadTelemetry/ProfileTelemetry.h
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#pragma once
-
-#ifdef AZ_PROFILE_TELEMETRY
-
-/*!
-* ProfileTelemetry.h provides a RAD Telemetry specific implementation of the AZ_PROFILE_FUNCTION, AZ_PROFILE_SCOPE, and AZ_PROFILE_SCOPE_DYNAMIC performance instrumentation markers
-*/
-
-#define TM_API_PTR g_radTmApi
-#include <rad_tm.h>
-#include <AzCore/Math/Color.h>
-
-namespace ProfileTelemetryInternal
-{
-    inline constexpr tm_uint32 ConvertColor(uint32_t rgba)
-    {
-        return
-            ((rgba >> 24) & 0x000000ff) | // move byte 3 to byte 0
-            ((rgba << 8) & 0x00ff0000) | // move byte 1 to byte 2
-            ((rgba >> 8) & 0x0000ff00) | // move byte 2 to byte 1
-            ((rgba << 24) & 0xff000000);  // byte 0 to byte 3
-    }
-
-    inline constexpr tm_uint32 ConvertColor(const AZ::Color& color)
-    {
-        return ConvertColor(color.ToU32());
-    }
-}
-
-#define  AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category) (static_cast<uint32_t>(1) << static_cast<uint32_t>(category))
-// Helpers
-#define AZ_INTERNAL_PROF_MEMORY_CAT_TO_FLAGS(category) (AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category) | \
-        AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(AZ::Debug::ProfileCategory::MemoryReserved))
-
-#define AZ_INTERNAL_PROF_VERIFY_INTERVAL_ID(id) static_assert(sizeof(id) <= sizeof(tm_uint64), "Interval id must be a unique value no larger than 64-bits")
-
-#define AZ_INTERNAL_PROF_TM_FUNC_VERIFY_CAT(category, flags) \
-    tmFunction(AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category), flags)
-
-#define AZ_INTERNAL_PROF_TM_ZONE_VERIFY_CAT(category, flags, ...) \
-    tmZone(AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category), flags, __VA_ARGS__)    
-
-// AZ_PROFILE_FUNCTION
-#define AZ_PROFILE_FUNCTION(category) \
-    AZ_INTERNAL_PROF_TM_FUNC_VERIFY_CAT(category, TMZF_NONE)
-
-#define AZ_PROFILE_FUNCTION_STALL(category) \
-    AZ_INTERNAL_PROF_TM_FUNC_VERIFY_CAT(category, TMZF_STALL)
-
-#define AZ_PROFILE_FUNCTION_IDLE(category) \
-    AZ_INTERNAL_PROF_TM_FUNC_VERIFY_CAT(category, TMZF_IDLE)
-
-
-// AZ_PROFILE_SCOPE
-#define AZ_PROFILE_SCOPE(category, name) \
-    AZ_INTERNAL_PROF_TM_ZONE_VERIFY_CAT(category, TMZF_NONE, name)
-
-#define AZ_PROFILE_SCOPE_STALL(category, name) \
-    AZ_INTERNAL_PROF_TM_ZONE_VERIFY_CAT(category, TMZF_STALL, name)
-
-#define AZ_PROFILE_SCOPE_IDLE(category, name) \
-     AZ_INTERNAL_PROF_TM_ZONE_VERIFY_CAT(category, TMZF_IDLE, name)
-
-// AZ_PROFILE_SCOPE_DYNAMIC
-// For profiling events with dynamic scope names
-// Note: the first variable argument must be a const format string
-// Usage: AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory, <printf style const format string>, format args...)
-#define AZ_PROFILE_SCOPE_DYNAMIC(category, ...) \
-        AZ_INTERNAL_PROF_TM_ZONE_VERIFY_CAT(category, TMZF_NONE, __VA_ARGS__)
-
-#define AZ_PROFILE_SCOPE_STALL_DYNAMIC(category, ...) \
-        AZ_INTERNAL_PROF_TM_ZONE_VERIFY_CAT(category, TMZF_STALL, __VA_ARGS__)
-
-#define AZ_PROFILE_SCOPE_IDLE_DYNAMIC(category, ...) \
-        AZ_INTERNAL_PROF_TM_ZONE_VERIFY_CAT(category, TMZF_IDLE, __VA_ARGS__)
-
-
-// AZ_PROFILE_EVENT_BEGIN/END
-// For profiling events that do not start and stop in the same scope (they MUST start/stop on the same thread)
-// ALWAYS favor using scoped events (AZ_PROFILE_FUNCTION, AZ_PROFILE_SCOPE) as debugging an unmatched begin/end can be challenging
-#define AZ_PROFILE_EVENT_BEGIN(category, name) \
-    tmEnter(AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category), TMZF_NONE, name)
-
-#define AZ_PROFILE_EVENT_END(category) \
-    tmLeave(AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category))
-
-
-// AZ_PROFILE_INTERVAL (mapped to Telemetry Timespan APIs)
-// Note: using C-style casting as we allow either pointers or integral types as IDs
-#define AZ_PROFILE_INTERVAL_START(category, id, ...) \
-    AZ_INTERNAL_PROF_VERIFY_INTERVAL_ID(id); \
-    tmBeginTimeSpan(AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category), (tm_uint64)(id), TMZF_NONE, __VA_ARGS__)
-
-#define AZ_PROFILE_INTERVAL_START_COLORED(category, id, color, ...) \
-    AZ_INTERNAL_PROF_VERIFY_INTERVAL_ID(id); \
-    tmBeginColoredTimeSpan(AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category), (tm_uint64)(id), 0, ProfileTelemetryInternal::ConvertColor(color), TMZF_NONE, __VA_ARGS__)
-
-#define AZ_PROFILE_INTERVAL_END(category, id) \
-    AZ_INTERNAL_PROF_VERIFY_INTERVAL_ID(id); \
-    tmEndTimeSpan(AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category), (tm_uint64)(id))
-
-// AZ_PROFILE_INTERVAL_SCOPED
-// Scoped interval event that implicitly starts and ends in the same scope
-// Note: using C-style casting as we allow either pointers or integral types as IDs
-// Note: the first variable argument must be a const format string
-// Usage: AZ_PROFILE_INTERVAL_SCOPED(AZ::Debug::ProfileCategory, <unique interval id>, <printf style const format string>, format args...)
-#define AZ_PROFILE_INTERVAL_SCOPED(category, id,  ...) \
-    AZ_INTERNAL_PROF_VERIFY_INTERVAL_ID(id); \
-    tmTimeSpan(AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category), (tm_uint64)(id), TM_MIN_TIME_SPAN_TRACK_ID + static_cast<AZ::Debug::ProfileCategoryPrimitiveType>(category), 0, TMZF_NONE, __VA_ARGS__)
-
-
-// AZ_PROFILE_DATAPOINT (mapped to tmPlot APIs)
-// Note: data points can have static or dynamic names, if using a dynamic name the first variable argument must be a const format string
-// Usage: AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory, <printf style const format string>, format args...)
-#define AZ_PROFILE_DATAPOINT(category, value, ...) \
-    tmPlot(AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category), TM_PLOT_UNITS_REAL, TM_PLOT_DRAW_LINE, static_cast<double>(value), __VA_ARGS__)
-
-#define AZ_PROFILE_DATAPOINT_PERCENT(category, value, ...) \
-    tmPlot(AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(category), TM_PLOT_UNITS_PERCENTAGE_DIRECT, TM_PLOT_DRAW_LINE, static_cast<double>(value), __VA_ARGS__)
-
-
-// AZ_PROFILE_MEMORY_ALLOC
-#define AZ_PROFILE_MEMORY_ALLOC(category, address, size, context) \
-    tmAlloc(AZ_INTERNAL_PROF_MEMORY_CAT_TO_FLAGS(category), address, size, context)
-
-#define AZ_PROFILE_MEMORY_ALLOC_EX(category, filename, lineNumber, address, size, context) \
-    tmAllocEx(AZ_INTERNAL_PROF_MEMORY_CAT_TO_FLAGS(category), filename, lineNumber, address, size, context)
-
-#define AZ_PROFILE_MEMORY_FREE(category, address) \
-    tmFree(AZ_INTERNAL_PROF_MEMORY_CAT_TO_FLAGS(category), address)
-
-#define AZ_PROFILE_MEMORY_FREE_EX(category, filename, lineNumber, address) \
-    tmFreeEx(AZ_INTERNAL_PROF_MEMORY_CAT_TO_FLAGS(category), filename, lineNumber, address)
-
-#endif
diff --git a/Code/Framework/AzCore/Platform/Common/RadTelemetry/ProfileTelemetryBus.h b/Code/Framework/AzCore/Platform/Common/RadTelemetry/ProfileTelemetryBus.h
deleted file mode 100644
index e572314723..0000000000
--- a/Code/Framework/AzCore/Platform/Common/RadTelemetry/ProfileTelemetryBus.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#pragma once
-
-#ifdef AZ_PROFILE_TELEMETRY
-
-#include <AzCore/base.h>
-#include <AzCore/Debug/Profiler.h>
-#include <AzCore/Debug/ProfilerBus.h>
-#include <AzCore/EBus/EBus.h>
-
-struct tm_api;
-
-namespace RADTelemetry
-{
-    class ProfileTelemetryRequests
-        : public AZ::EBusTraits
-    {
-    public:
-        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
-
-        virtual ~ProfileTelemetryRequests() = default;
-
-        virtual void ToggleEnabled() = 0;
-
-        virtual void SetAddress(const char* address, AZ::u16 port) = 0;
-
-        virtual void SetCaptureMask(AZ::Debug::ProfileCategoryPrimitiveType mask) = 0;
-
-        virtual void SetFrameAdvanceType(AZ::Debug::ProfileFrameAdvanceType type) = 0;
-
-        virtual AZ::Debug::ProfileCategoryPrimitiveType GetCaptureMask() = 0;
-
-        virtual AZ::Debug::ProfileCategoryPrimitiveType GetDefaultCaptureMask() = 0;
-
-        virtual tm_api* GetApiInstance() = 0;
-    };
-
-    using ProfileTelemetryRequestBus = AZ::EBus<ProfileTelemetryRequests>;
-}
-
-#endif
diff --git a/Code/Framework/AzCore/Platform/Mac/profile_telemetry_platform_mac.cmake b/Code/Framework/AzCore/Platform/Mac/profile_telemetry_platform_mac.cmake
index df12777586..9ecf9fd999 100644
--- a/Code/Framework/AzCore/Platform/Mac/profile_telemetry_platform_mac.cmake
+++ b/Code/Framework/AzCore/Platform/Mac/profile_telemetry_platform_mac.cmake
@@ -11,7 +11,3 @@
 # NOTE: functions in cmake are global, therefore adding functions to this file
 # is being avoided to prevent overriding functions declared in other targets platfrom
 # specific cmake files
-
-if(LY_RAD_TELEMETRY_ENABLED)
-    set(LY_COMPILE_DEFINITIONS PUBLIC AZ_PROFILE_TELEMETRY)
-endif()
diff --git a/Code/Framework/AzCore/Platform/Windows/profile_telemetry_platform_windows.cmake b/Code/Framework/AzCore/Platform/Windows/profile_telemetry_platform_windows.cmake
index df12777586..9ecf9fd999 100644
--- a/Code/Framework/AzCore/Platform/Windows/profile_telemetry_platform_windows.cmake
+++ b/Code/Framework/AzCore/Platform/Windows/profile_telemetry_platform_windows.cmake
@@ -11,7 +11,3 @@
 # NOTE: functions in cmake are global, therefore adding functions to this file
 # is being avoided to prevent overriding functions declared in other targets platfrom
 # specific cmake files
-
-if(LY_RAD_TELEMETRY_ENABLED)
-    set(LY_COMPILE_DEFINITIONS PUBLIC AZ_PROFILE_TELEMETRY)
-endif()
diff --git a/Code/Framework/AzCore/Platform/iOS/profile_telemetry_platform_ios.cmake b/Code/Framework/AzCore/Platform/iOS/profile_telemetry_platform_ios.cmake
index aeb91ebce6..7a325ca97e 100644
--- a/Code/Framework/AzCore/Platform/iOS/profile_telemetry_platform_ios.cmake
+++ b/Code/Framework/AzCore/Platform/iOS/profile_telemetry_platform_ios.cmake
@@ -5,7 +5,3 @@
 # SPDX-License-Identifier: Apache-2.0 OR MIT
 #
 #
-
-if(LY_RAD_TELEMETRY_ENABLED)
-    set(LY_COMPILE_DEFINITIONS PUBLIC AZ_PROFILE_TELEMETRY)
-endif()
diff --git a/Code/Framework/AzCore/Tests/TimeDataStatistics.cpp b/Code/Framework/AzCore/Tests/TimeDataStatistics.cpp
index 50856b1df8..f75d401c1f 100644
--- a/Code/Framework/AzCore/Tests/TimeDataStatistics.cpp
+++ b/Code/Framework/AzCore/Tests/TimeDataStatistics.cpp
@@ -83,7 +83,7 @@ namespace UnitTest
 
         int ChildFunction0(int numIterations, int sleepTimeMilliseconds)
         {
-            AZ_PROFILE_TIMER("UnitTest", CHILD_TIMER_STAT0);
+            AZ_PROFILE_SCOPE(UnitTest, CHILD_TIMER_STAT0);
             AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(sleepTimeMilliseconds));
             int result = 5;
             for (int i = 0; i < numIterations; ++i)
@@ -95,7 +95,7 @@ namespace UnitTest
 
         int ChildFunction1(int numIterations, int sleepTimeMilliseconds)
         {
-            AZ_PROFILE_TIMER("UnitTest", CHILD_TIMER_STAT1);
+            AZ_PROFILE_SCOPE(UnitTest, CHILD_TIMER_STAT1);
             AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(sleepTimeMilliseconds));
             int result = 5;
             for (int i = 0; i < numIterations; ++i)
@@ -107,7 +107,7 @@ namespace UnitTest
 
         int ParentFunction(int numIterations, int sleepTimeMilliseconds)
         {
-            AZ_PROFILE_TIMER("UnitTest", PARENT_TIMER_STAT);
+            AZ_PROFILE_SCOPE(UnitTest, PARENT_TIMER_STAT);
             AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(sleepTimeMilliseconds));
             int result = 0;
             result += ChildFunction0(numIterations, sleepTimeMilliseconds);
@@ -198,9 +198,10 @@ namespace UnitTest
         AZStd::unique_ptr<Statistics::TimeDataStatisticsManager> m_statsManager;
     };//class TimeDataStatisticsManagerTest
 
-    TEST_F(TimeDataStatisticsManagerTest, Test)
+    // TODO:BUDGETS disabled until profiler budgets system comes online
+    // TEST_F(TimeDataStatisticsManagerTest, Test)
     {
-        run();
+        // run();
     }
     //End of all Tests of TimeDataStatisticsManagerTest
 
diff --git a/Code/Legacy/CryCommon/ISystem.h b/Code/Legacy/CryCommon/ISystem.h
index d8aba337d5..74153eb39b 100644
--- a/Code/Legacy/CryCommon/ISystem.h
+++ b/Code/Legacy/CryCommon/ISystem.h
@@ -1149,22 +1149,11 @@ struct DiskOperationInfo
 
 #endif
 
-#if defined(ENABLE_LOADING_PROFILER) && AZ_PROFILE_TELEMETRY
-
-#define LOADING_TIME_PROFILE_SECTION AZ_PROFILE_FUNCTION(AzCore)
-#define LOADING_TIME_PROFILE_SECTION_ARGS(...) AZ_PROFILE_SCOPE(AzCore, __VA_ARGS__)
-#define LOADING_TIME_PROFILE_SECTION_NAMED(sectionName) AZ_PROFILE_SCOPE(AzCore, sectionName)
-#define LOADING_TIME_PROFILE_SECTION_NAMED_ARGS(sectionName, ...) AZ_PROFILE_SCOPE(AzCore, sectionName, __VA_ARGS__)
-
-#else
-
 #define LOADING_TIME_PROFILE_SECTION
 #define LOADING_TIME_PROFILE_SECTION_ARGS(...)
 #define LOADING_TIME_PROFILE_SECTION_NAMED(sectionName)
 #define LOADING_TIME_PROFILE_SECTION_NAMED_ARGS(sectionName, ...)
 
-#endif
-
 //////////////////////////////////////////////////////////////////////////
 // CrySystem DLL Exports.
 //////////////////////////////////////////////////////////////////////////
diff --git a/Code/Legacy/CryCommon/ProjectDefines.h b/Code/Legacy/CryCommon/ProjectDefines.h
index 18b4665fab..c7740db95c 100644
--- a/Code/Legacy/CryCommon/ProjectDefines.h
+++ b/Code/Legacy/CryCommon/ProjectDefines.h
@@ -173,7 +173,7 @@
 
 #if defined(ENABLE_PROFILING_CODE)
     #define USE_DISK_PROFILER
-    #define ENABLE_LOADING_PROFILER  // requires AZ_PROFILE_TELEMETRY to also be defined
+    #define ENABLE_LOADING_PROFILER
 #endif
 
 // The maximum number of joints in an animation
diff --git a/Code/Legacy/CryCommon/platform_impl.cpp b/Code/Legacy/CryCommon/platform_impl.cpp
index dc8a555286..ecc196a49f 100644
--- a/Code/Legacy/CryCommon/platform_impl.cpp
+++ b/Code/Legacy/CryCommon/platform_impl.cpp
@@ -13,7 +13,6 @@
 #include <IConsole.h>
 
 #include <AzCore/Debug/Profiler.h>
-#include <AzCore/Debug/ProfileModuleInit.h>
 #include <AzCore/Memory/AllocatorManager.h>
 #include <AzCore/Module/Environment.h>
 #include <AzCore/std/string/conversions.h>
@@ -94,7 +93,6 @@ extern "C" AZ_DLL_EXPORT void ModuleInitISystem(ISystem* pSystem, [[maybe_unused
             AZ::Environment::Attach(gEnv->pSharedEnvironment);
             AZ::AllocatorManager::Instance();  // Force the AllocatorManager to instantiate and register any allocators defined in data sections
         }
-        AZ::Debug::ProfileModuleInit();
     } // if pSystem
 }
 
diff --git a/Gems/RADTelemetry/CMakeLists.txt b/Gems/RADTelemetry/CMakeLists.txt
deleted file mode 100644
index 2bb380fae3..0000000000
--- a/Gems/RADTelemetry/CMakeLists.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-#
-# Copyright (c) Contributors to the Open 3D Engine Project.
-# For complete copyright and license terms please see the LICENSE at the root of this distribution.
-#
-# SPDX-License-Identifier: Apache-2.0 OR MIT
-#
-#
-
-add_subdirectory(Code)
diff --git a/Gems/RADTelemetry/Code/CMakeLists.txt b/Gems/RADTelemetry/Code/CMakeLists.txt
deleted file mode 100644
index 544540f273..0000000000
--- a/Gems/RADTelemetry/Code/CMakeLists.txt
+++ /dev/null
@@ -1,47 +0,0 @@
-#
-# Copyright (c) Contributors to the Open 3D Engine Project.
-# For complete copyright and license terms please see the LICENSE at the root of this distribution.
-#
-# SPDX-License-Identifier: Apache-2.0 OR MIT
-#
-#
-
-set(LY_RAD_TELEMETRY_ENABLED OFF CACHE BOOL "Enables RAD Telemetry in Debug/Profile mode.")
-set(LY_RAD_TELEMETRY_INSTALL_ROOT "@LY_3RDPARTY_PATH@/RadTelemetry" CACHE PATH "Install path to RAD Telemetry.")
-string(CONFIGURE ${LY_RAD_TELEMETRY_INSTALL_ROOT} LY_RAD_TELEMETRY_INSTALL_ROOT @ONLY)
-
-ly_get_list_relative_pal_filename(pal_source_dir ${CMAKE_CURRENT_LIST_DIR}/Source/Platform/${PAL_PLATFORM_NAME})
-
-ly_add_target(
-    NAME RADTelemetry.Static STATIC
-    NAMESPACE Gem
-    FILES_CMAKE
-        radtelemetry_files.cmake
-        ${pal_source_dir}/platform_${PAL_PLATFORM_NAME_LOWERCASE}_files.cmake
-    INCLUDE_DIRECTORIES
-        PRIVATE
-            Source
-            ${pal_source_dir}
-    BUILD_DEPENDENCIES
-        PUBLIC
-            AZ::AzCore
-            Legacy::CryCommon
-)
-
-ly_add_target(
-    NAME RADTelemetry ${PAL_TRAIT_MONOLITHIC_DRIVEN_MODULE_TYPE}
-    NAMESPACE Gem
-    FILES_CMAKE
-        radtelemetry_shared_files.cmake
-    INCLUDE_DIRECTORIES
-        PRIVATE
-            Source
-    BUILD_DEPENDENCIES
-        PRIVATE
-            Gem::RADTelemetry.Static
-)
-
-# the RADTelemetry module above can be used in all kinds of applications, but we don't enable it in asset builders
-ly_create_alias(NAME RADTelemetry.Clients NAMESPACE Gem TARGETS Gem::RADTelemetry)
-ly_create_alias(NAME RADTelemetry.Tools   NAMESPACE Gem TARGETS Gem::RADTelemetry)
-ly_create_alias(NAME RADTelemetry.Servers NAMESPACE Gem TARGETS Gem::RADTelemetry)
diff --git a/Gems/RADTelemetry/Code/Source/Platform/Android/RADTelemetry_Traits_Platform.h b/Gems/RADTelemetry/Code/Source/Platform/Android/RADTelemetry_Traits_Platform.h
deleted file mode 100644
index 8b524df127..0000000000
--- a/Gems/RADTelemetry/Code/Source/Platform/Android/RADTelemetry_Traits_Platform.h
+++ /dev/null
@@ -1,10 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#define AZ_TRAIT_RAD_TELEMETRY_OPEN_FLAGS TMOF_INIT_NETWORKING
diff --git a/Gems/RADTelemetry/Code/Source/Platform/Android/platform_android_files.cmake b/Gems/RADTelemetry/Code/Source/Platform/Android/platform_android_files.cmake
deleted file mode 100644
index 6e7a9dd5eb..0000000000
--- a/Gems/RADTelemetry/Code/Source/Platform/Android/platform_android_files.cmake
+++ /dev/null
@@ -1,11 +0,0 @@
-#
-# Copyright (c) Contributors to the Open 3D Engine Project.
-# For complete copyright and license terms please see the LICENSE at the root of this distribution.
-#
-# SPDX-License-Identifier: Apache-2.0 OR MIT
-#
-#
-
-set(FILES
-    RADTelemetry_Traits_Platform.h
-)
diff --git a/Gems/RADTelemetry/Code/Source/Platform/Linux/RADTelemetry_Traits_Platform.h b/Gems/RADTelemetry/Code/Source/Platform/Linux/RADTelemetry_Traits_Platform.h
deleted file mode 100644
index 8b524df127..0000000000
--- a/Gems/RADTelemetry/Code/Source/Platform/Linux/RADTelemetry_Traits_Platform.h
+++ /dev/null
@@ -1,10 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#define AZ_TRAIT_RAD_TELEMETRY_OPEN_FLAGS TMOF_INIT_NETWORKING
diff --git a/Gems/RADTelemetry/Code/Source/Platform/Linux/platform_linux_files.cmake b/Gems/RADTelemetry/Code/Source/Platform/Linux/platform_linux_files.cmake
deleted file mode 100644
index 6e7a9dd5eb..0000000000
--- a/Gems/RADTelemetry/Code/Source/Platform/Linux/platform_linux_files.cmake
+++ /dev/null
@@ -1,11 +0,0 @@
-#
-# Copyright (c) Contributors to the Open 3D Engine Project.
-# For complete copyright and license terms please see the LICENSE at the root of this distribution.
-#
-# SPDX-License-Identifier: Apache-2.0 OR MIT
-#
-#
-
-set(FILES
-    RADTelemetry_Traits_Platform.h
-)
diff --git a/Gems/RADTelemetry/Code/Source/Platform/Mac/RADTelemetry_Traits_Platform.h b/Gems/RADTelemetry/Code/Source/Platform/Mac/RADTelemetry_Traits_Platform.h
deleted file mode 100644
index 8b524df127..0000000000
--- a/Gems/RADTelemetry/Code/Source/Platform/Mac/RADTelemetry_Traits_Platform.h
+++ /dev/null
@@ -1,10 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#define AZ_TRAIT_RAD_TELEMETRY_OPEN_FLAGS TMOF_INIT_NETWORKING
diff --git a/Gems/RADTelemetry/Code/Source/Platform/Mac/platform_mac_files.cmake b/Gems/RADTelemetry/Code/Source/Platform/Mac/platform_mac_files.cmake
deleted file mode 100644
index 6e7a9dd5eb..0000000000
--- a/Gems/RADTelemetry/Code/Source/Platform/Mac/platform_mac_files.cmake
+++ /dev/null
@@ -1,11 +0,0 @@
-#
-# Copyright (c) Contributors to the Open 3D Engine Project.
-# For complete copyright and license terms please see the LICENSE at the root of this distribution.
-#
-# SPDX-License-Identifier: Apache-2.0 OR MIT
-#
-#
-
-set(FILES
-    RADTelemetry_Traits_Platform.h
-)
diff --git a/Gems/RADTelemetry/Code/Source/Platform/Windows/RADTelemetry_Traits_Platform.h b/Gems/RADTelemetry/Code/Source/Platform/Windows/RADTelemetry_Traits_Platform.h
deleted file mode 100644
index 8b524df127..0000000000
--- a/Gems/RADTelemetry/Code/Source/Platform/Windows/RADTelemetry_Traits_Platform.h
+++ /dev/null
@@ -1,10 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#define AZ_TRAIT_RAD_TELEMETRY_OPEN_FLAGS TMOF_INIT_NETWORKING
diff --git a/Gems/RADTelemetry/Code/Source/Platform/Windows/platform_windows_files.cmake b/Gems/RADTelemetry/Code/Source/Platform/Windows/platform_windows_files.cmake
deleted file mode 100644
index 6e7a9dd5eb..0000000000
--- a/Gems/RADTelemetry/Code/Source/Platform/Windows/platform_windows_files.cmake
+++ /dev/null
@@ -1,11 +0,0 @@
-#
-# Copyright (c) Contributors to the Open 3D Engine Project.
-# For complete copyright and license terms please see the LICENSE at the root of this distribution.
-#
-# SPDX-License-Identifier: Apache-2.0 OR MIT
-#
-#
-
-set(FILES
-    RADTelemetry_Traits_Platform.h
-)
diff --git a/Gems/RADTelemetry/Code/Source/Platform/iOS/RADTelemetry_Traits_Platform.h b/Gems/RADTelemetry/Code/Source/Platform/iOS/RADTelemetry_Traits_Platform.h
deleted file mode 100644
index 8b524df127..0000000000
--- a/Gems/RADTelemetry/Code/Source/Platform/iOS/RADTelemetry_Traits_Platform.h
+++ /dev/null
@@ -1,10 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-#pragma once
-
-#define AZ_TRAIT_RAD_TELEMETRY_OPEN_FLAGS TMOF_INIT_NETWORKING
diff --git a/Gems/RADTelemetry/Code/Source/Platform/iOS/platform_ios_files.cmake b/Gems/RADTelemetry/Code/Source/Platform/iOS/platform_ios_files.cmake
deleted file mode 100644
index 6e7a9dd5eb..0000000000
--- a/Gems/RADTelemetry/Code/Source/Platform/iOS/platform_ios_files.cmake
+++ /dev/null
@@ -1,11 +0,0 @@
-#
-# Copyright (c) Contributors to the Open 3D Engine Project.
-# For complete copyright and license terms please see the LICENSE at the root of this distribution.
-#
-# SPDX-License-Identifier: Apache-2.0 OR MIT
-#
-#
-
-set(FILES
-    RADTelemetry_Traits_Platform.h
-)
diff --git a/Gems/RADTelemetry/Code/Source/ProfileTelemetryComponent.cpp b/Gems/RADTelemetry/Code/Source/ProfileTelemetryComponent.cpp
deleted file mode 100644
index 7e38f76592..0000000000
--- a/Gems/RADTelemetry/Code/Source/ProfileTelemetryComponent.cpp
+++ /dev/null
@@ -1,344 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#ifdef AZ_PROFILE_TELEMETRY
-
-#include <AzCore/Debug/ProfilerBus.h>
-#include <AzCore/PlatformIncl.h>
-#include <AzCore/Serialization/SerializeContext.h>
-
-#include <RADTelemetry/ProfileTelemetry.h>
-#include <RADTelemetry_Traits_Platform.h>
-
-#include "ProfileTelemetryComponent.h"
-
-namespace RADTelemetry
-{
-    static const char * ProfileChannel = "RADTelemetry";
-    static const AZ::u32 MaxProfileThreadCount = 128;
-
-    static void MessageFrameTickType(AZ::Debug::ProfileFrameAdvanceType type)
-    {
-        const char * frameAdvanceTypeMessage = "Profile tick set to %s";
-        const char* frameAdvanceTypeString = (type == AZ::Debug::ProfileFrameAdvanceType::Game) ? "Game Thread" : "Render Frame";
-        AZ_Printf(ProfileChannel, frameAdvanceTypeMessage, frameAdvanceTypeString);
-        tmMessage(0, TMMF_SEVERITY_LOG, frameAdvanceTypeMessage, frameAdvanceTypeString);
-    }
-
-    ProfileTelemetryComponent::ProfileTelemetryComponent()
-    {
-        // Connecting in the constructor because we need to catch ALL created threads
-        AZStd::ThreadEventBus::Handler::BusConnect();
-    }
-
-    ProfileTelemetryComponent::~ProfileTelemetryComponent()
-    {
-        AZ_Assert(!m_running, "A telemetry session should not be open.");
-
-        AZStd::ThreadEventBus::Handler::BusDisconnect();
-
-        if (IsInitialized())
-        {
-            tmShutdown();
-            AZ_OS_FREE(m_buffer);
-            m_buffer = nullptr;
-        }
-    }
-
-    void ProfileTelemetryComponent::Activate()
-    {
-        AZ::Debug::ProfilerRequestBus::Handler::BusConnect();
-        ProfileTelemetryRequestBus::Handler::BusConnect();
-        AZ::SystemTickBus::Handler::BusConnect();
-    }
-
-    void ProfileTelemetryComponent::Deactivate()
-    {
-        AZ::SystemTickBus::Handler::BusDisconnect();
-        ProfileTelemetryRequestBus::Handler::BusDisconnect();
-        AZ::Debug::ProfilerRequestBus::Handler::BusDisconnect();
-
-        Disable();
-    }
-
-    void ProfileTelemetryComponent::OnThreadEnter(const AZStd::thread_id& id, const AZStd::thread_desc* desc)
-    {
-        (void)id;
-        (void)desc;
-#if AZ_TRAIT_OS_USE_WINDOWS_THREADS
-        if (!desc)
-        {
-            // Skip unnamed threads
-            return;
-        }
-
-        if (IsInitialized())
-        {
-            // We can send the thread name to Telemetry now
-            const AZ::u32 newProfiledThreadCount = ++m_profiledThreadCount;
-            AZ_Assert(newProfiledThreadCount <= MaxProfileThreadCount, "RAD Telemetry profiled threadcount exceeded MaxProfileThreadCount!");
-            tmThreadName(0, id.m_id, desc->m_name);
-            return;
-        }
-
-        // Save off to send on the next connection
-        ScopedLock lock(m_threadNameLock);
-
-        auto end = m_threadNames.end();
-        auto itr = AZStd::find_if(m_threadNames.begin(), end, [id](const ThreadNameEntry& entry)
-        {
-            return entry.id == id;
-        });
-
-        if (itr != end)
-        {
-            itr->name = desc->m_name;
-        }
-        else
-        {
-            m_threadNames.push_back({ id, desc->m_name });
-        }
-#else
-        const AZ::u32 newProfiledThreadCount = ++m_profiledThreadCount;
-        AZ_Assert(newProfiledThreadCount <= MaxProfileThreadCount, "RAD Telemetry profiled threadcount exceeded MaxProfileThreadCount!");
-#endif
-    }
-
-    void ProfileTelemetryComponent::OnThreadExit(const AZStd::thread_id& id)
-    {
-        (void)id;
-#if AZ_TRAIT_OS_USE_WINDOWS_THREADS
-        {
-            ScopedLock lock(m_threadNameLock);
-
-            auto end = m_threadNames.end();
-            auto itr = AZStd::find_if(m_threadNames.begin(), end, [id](const ThreadNameEntry& entry)
-            {
-                return entry.id == id;
-            });
-            if (itr != end)
-            {
-                m_threadNames.erase(itr);
-            }
-            else
-            {
-                // assume it was already sent on to RAD Telemetry
-                tmEndThread(0, id.m_id);
-                --m_profiledThreadCount;
-            }
-        }
-#else
-        --m_profiledThreadCount;
-#endif
-    }
-
-    void ProfileTelemetryComponent::OnSystemTick()
-    {
-        FrameAdvance(AZ::Debug::ProfileFrameAdvanceType::Game);
-    }
-
-    void ProfileTelemetryComponent::FrameAdvance(AZ::Debug::ProfileFrameAdvanceType type)
-    {
-        if (type == m_frameAdvanceType)
-        {
-            tmTick(0);
-        }
-    }
-
-    bool ProfileTelemetryComponent::IsActive()
-    {
-        return m_running;
-    }
-
-    void ProfileTelemetryComponent::ToggleEnabled()
-    {
-        Initialize();
-
-        if (!m_running)
-        {
-            Enable();
-        }
-        else
-        {
-            Disable();
-        }
-    }
-
-    tm_api* ProfileTelemetryComponent::GetApiInstance()
-    {
-        Initialize();
-
-        return TM_API_PTR;
-    }
-
-    void ProfileTelemetryComponent::Enable()
-    {
-        AZ_Printf(ProfileChannel, "Attempting to connect to the Telemetry server at %s:%d", m_address, m_port);
-
-        tmSetCaptureMask(m_captureMask);
-        tm_error result = tmOpen(
-            0,                      // unused
-            "ly",                   // program name, don't use slashes or weird character that will screw up a filename
-            __DATE__ " " __TIME__,  // identifier, could be date time, or a build number ... whatever you want
-            m_address,              // telemetry server address
-            TMCT_TCP,               // network capture
-            m_port,                 // telemetry server port
-            AZ_TRAIT_RAD_TELEMETRY_OPEN_FLAGS,// flags
-            3000                    // timeout in milliseconds ... pass -1 for infinite
-        );
-
-        switch (result)
-        {
-            case TM_OK:
-            {
-                m_running = true;
-                AZ_Printf(ProfileChannel, "Connected to the Telemetry server at %s:%d", m_address, m_port);
-                MessageFrameTickType(m_frameAdvanceType);
-
-#if AZ_TRAIT_OS_USE_WINDOWS_THREADS
-                ScopedLock lock(m_threadNameLock);
-                for (const auto& threadNameEntry : m_threadNames)
-                {
-                    const AZ::u32 newProfiledThreadCount = ++m_profiledThreadCount;
-                    AZ_Assert(newProfiledThreadCount <= MaxProfileThreadCount, "RAD Telemetry profiled thread count exceeded MaxProfileThreadCount!");
-                    tmThreadName(0, threadNameEntry.id.m_id, threadNameEntry.name.c_str());
-                }
-                m_threadNames.clear(); // Telemetry caches names so we can clear what we have sent on
-#endif
-                break;
-            }
-
-            case TMERR_DISABLED:
-                AZ_Printf(ProfileChannel, "Telemetry is disabled via #define NTELEMETRY");
-                break;
-
-            case TMERR_UNINITIALIZED:
-                AZ_Printf(ProfileChannel, "tmInitialize failed or was not called");
-                break;
-
-            case TMERR_NETWORK_NOT_INITIALIZED:
-                AZ_Printf(ProfileChannel, "WSAStartup was not called before tmOpen! Call WSAStartup or pass TMOF_INIT_NETWORKING.");
-                break;
-
-            case TMERR_NULL_API:
-                AZ_Printf(ProfileChannel, "There is no Telemetry API (the DLL isn't in the EXE's path)!");
-                break;
-
-            case TMERR_COULD_NOT_CONNECT:
-                AZ_Printf(ProfileChannel, "Unable to connect to the Telemetry server at %s:%d (1. is it running? 2. check firewall settings)", m_address, m_port);
-                break;
-
-            case TMERR_UNKNOWN:
-                AZ_Printf(ProfileChannel, "Unknown error occurred");
-                break;
-
-            default:
-                AZ_Assert(false, "Unhandled tmOpen error case %d", result);
-                break;
-        }
-    }
-
-    void ProfileTelemetryComponent::Disable()
-    {
-        if (m_running)
-        {
-            m_running = false;
-            tmClose(0);
-            AZ_Printf(ProfileChannel, "Disconnected from the Telemetry server.");
-        }
-    }
-
-    TM_EXPORT_API tm_api* g_tm_api; // Required for the RAD Telemetry as static lib case
-    void ProfileTelemetryComponent::Initialize()
-    {
-        if (IsInitialized())
-        {
-            return;
-        }
-
-        tmLoadLibrary(TM_RELEASE);
-        if (!TM_API_PTR)
-        {
-            // Work around for UnixLike platforms that do not load RAD Telemetry static lib (they are incorrectly compiled with the dynamic library version of tmLoadLibrary.  RAD is aware of the issue.)
-            TM_API_PTR = g_tm_api;
-        }
-        AZ_Assert(TM_API_PTR, "Invalid RAD Telemetry API pointer state");
-
-        tmSetMaxThreadCount(MaxProfileThreadCount);
-
-        const tm_int32 telemetryBufferSize = 16 * 1024 * 1024;
-        m_buffer = static_cast<char*>(AZ_OS_MALLOC(telemetryBufferSize, sizeof(void*)));
-        tmInitialize(telemetryBufferSize, m_buffer);
-
-        // Notify so individual modules can update their Telemetry pointer
-        AZ::Debug::ProfilerNotificationBus::Broadcast(&AZ::Debug::ProfilerNotifications::OnProfileSystemInitialized);
-    }
-
-    bool ProfileTelemetryComponent::IsInitialized() const {
-        return m_buffer != nullptr;
-    }
-
-    void ProfileTelemetryComponent::SetAddress(const char *address, AZ::u16 port)
-    {
-        m_address = address;
-        m_port = port;
-    }
-
-    void ProfileTelemetryComponent::SetCaptureMask(AZ::Debug::ProfileCategoryPrimitiveType mask)
-    {
-        m_captureMask = mask;
-        if (IsInitialized())
-        {
-            tmSetCaptureMask(m_captureMask);
-        }
-    }
-
-    void ProfileTelemetryComponent::SetFrameAdvanceType(AZ::Debug::ProfileFrameAdvanceType type)
-    {
-        if (type != m_frameAdvanceType)
-        {
-            MessageFrameTickType(type);
-            m_frameAdvanceType = type;
-        }
-    }
-
-    AZ::Debug::ProfileCategoryPrimitiveType ProfileTelemetryComponent::GetDefaultCaptureMaskInternal()
-    {
-        using MaskType = AZ::Debug::ProfileCategoryPrimitiveType;
-
-        // Set all the category bits "below" FirstDetailedCategory and do not enable memory capture by default
-        return (static_cast<MaskType>(1) << static_cast<MaskType>(FirstDetailedCategory)) - 1;
-    }
-
-    AZ::Debug::ProfileCategoryPrimitiveType ProfileTelemetryComponent::GetDefaultCaptureMask()
-    {
-        return GetDefaultCaptureMaskInternal();
-    }
-
-    AZ::Debug::ProfileCategoryPrimitiveType ProfileTelemetryComponent::GetCaptureMask()
-    {
-        return m_captureMask;
-    }
-
-    void ProfileTelemetryComponent::Reflect(AZ::ReflectContext* context)
-    {
-        if (AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
-        {
-            serializeContext->Class<ProfileTelemetryComponent, AZ::Component>()
-                ->Version(1)
-                ;
-        }
-    }
-
-    void ProfileTelemetryComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
-    {
-        provided.push_back(AZ_CRC("ProfilerService"));
-    }
-}
-
-#endif
diff --git a/Gems/RADTelemetry/Code/Source/ProfileTelemetryComponent.h b/Gems/RADTelemetry/Code/Source/ProfileTelemetryComponent.h
deleted file mode 100644
index 44fb1e5b4a..0000000000
--- a/Gems/RADTelemetry/Code/Source/ProfileTelemetryComponent.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#pragma once
-
-#ifdef AZ_PROFILE_TELEMETRY
-
-#include <AzCore/std/parallel/threadbus.h>
-#include <AzCore/Component/Component.h>
-#include <AzCore/Component/TickBus.h>
-#include <AzCore/std/string/string.h>
-
-#include <RADTelemetry/ProfileTelemetryBus.h>
-
-namespace RADTelemetry
-{
-    class ProfileTelemetryComponent
-        : public AZ::Component
-        , private AZStd::ThreadEventBus::Handler
-        , private AZ::SystemTickBus::Handler
-        , private AZ::Debug::ProfilerRequestBus::Handler
-        , private ProfileTelemetryRequestBus::Handler
-    {
-    public:
-        AZ_COMPONENT(ProfileTelemetryComponent, "{51118122-7214-4918-BFF3-237E25FF4918}");
-
-        ProfileTelemetryComponent();
-        ~ProfileTelemetryComponent() override;
-
-        //////////////////////////////////////////////////////////////////////////
-        // AZ::Component
-        void Activate() override;
-        void Deactivate() override;
-
-    private:
-        ProfileTelemetryComponent(const ProfileTelemetryComponent&) = delete;
-        //////////////////////////////////////////////////////////////////////////
-        // Thread event bus
-        void OnThreadEnter(const AZStd::thread_id& id, const AZStd::thread_desc* desc) override;
-        void OnThreadExit(const AZStd::thread_id& id) override;
-
-        //////////////////////////////////////////////////////////////////////////
-        // SystemTickBus
-        void OnSystemTick() override;
-
-        //////////////////////////////////////////////////////////////////////////
-        // ProfilerRequstBus
-        bool IsActive() override;
-        void FrameAdvance(AZ::Debug::ProfileFrameAdvanceType type) override;
-
-        //////////////////////////////////////////////////////////////////////////
-        // ProfileTelemetryRequestBus
-        void ToggleEnabled() override;
-        void SetAddress(const char *address, AZ::u16 port) override;
-        void SetCaptureMask(AZ::Debug::ProfileCategoryPrimitiveType mask) override;
-        void SetFrameAdvanceType(AZ::Debug::ProfileFrameAdvanceType type) override;
-
-        AZ::Debug::ProfileCategoryPrimitiveType GetCaptureMask() override;
-        AZ::Debug::ProfileCategoryPrimitiveType GetDefaultCaptureMask() override;
-        tm_api* GetApiInstance() override;
-
-        //////////////////////////////////////////////////////////////////////////
-        // Component descriptor
-        static void Reflect(AZ::ReflectContext* context);
-        static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided);
-
-        //////////////////////////////////////////////////////////////////////////
-        // Private helpers
-        void Enable();
-        void Disable();
-        void Initialize();
-        bool IsInitialized() const;
-        static AZ::Debug::ProfileCategoryPrimitiveType GetDefaultCaptureMaskInternal();
-
-        //////////////////////////////////////////////////////////////////////////
-        // Data members
-        struct ThreadNameEntry
-        {
-            AZStd::thread_id id;
-            AZStd::string name;
-        };
-        AZStd::vector<ThreadNameEntry> m_threadNames;
-        using LockType = AZStd::mutex;
-        using ScopedLock = AZStd::lock_guard<LockType>;
-        LockType m_threadNameLock;
-        AZStd::atomic_uint m_profiledThreadCount = { 0 };
-
-        const char* m_address = "127.0.0.1";
-        char* m_buffer = nullptr;
-        AZ::Debug::ProfileCategoryPrimitiveType m_captureMask = GetDefaultCaptureMaskInternal();
-        AZ::Debug::ProfileFrameAdvanceType m_frameAdvanceType = AZ::Debug::ProfileFrameAdvanceType::Game;
-        AZ::u16 m_port = 4719;
-        bool m_running = false;
-        bool m_initialized = false;
-    };
-}
-
-#endif
diff --git a/Gems/RADTelemetry/Code/Source/RADTelemetryModule.cpp b/Gems/RADTelemetry/Code/Source/RADTelemetryModule.cpp
deleted file mode 100644
index dc23505833..0000000000
--- a/Gems/RADTelemetry/Code/Source/RADTelemetryModule.cpp
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include <IGem.h>
-#include <IConsole.h>
-#include <cstdint>
-#include <cstdio> // snprintf
-#include <limits>
-
-#include "ProfileTelemetryComponent.h"
-
-namespace RADTelemetry
-{
-#ifdef AZ_PROFILE_TELEMETRY
-    using TelemetryRequestBus = RADTelemetry::ProfileTelemetryRequestBus;
-    using TelemetryRequests = RADTelemetry::ProfileTelemetryRequests;
-    using MaskType = AZ::Debug::ProfileCategoryPrimitiveType;
-
-    static const char* s_telemetryAddress;
-    static int s_telemetryPort;
-    static const char* s_telemetryCaptureMask;
-    static int s_memCaptureEnabled;
-    static int s_frameAdvanceType;
-
-    using FrameAdvanceType = AZ::Debug::ProfileFrameAdvanceType;
-
-    static void MaskCvarChangedCallback(ICVar*)
-    {
-        if (!s_telemetryCaptureMask || !s_telemetryCaptureMask[0])
-        {
-            return;
-        }
-
-        // Parse as a 64-bit hex string
-        MaskType maskCvarValue = strtoull(s_telemetryCaptureMask, nullptr, 16);
-        if (maskCvarValue == std::numeric_limits<MaskType>::max())
-        {
-            MaskType defaultMask = 0;
-            TelemetryRequestBus::BroadcastResult(defaultMask, &TelemetryRequests::GetDefaultCaptureMask);
-
-            AZ_Error("RADTelemetryGem", false, "Invalid RAD Telemetry capture mask cvar value: %s, using default capture mask 0x%" PRIx64, s_telemetryCaptureMask, defaultMask);
-            maskCvarValue = defaultMask;
-        }
-
-        // Mask off the memory capture flag and add it back if memory capture is enabled
-        const MaskType fullCaptureMask = (maskCvarValue & ~AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(MemoryReserved)) | (s_memCaptureEnabled ? AZ_PROFILE_CAT_TO_RAD_CAPFLAGS(MemoryReserved) : 0);
-        TelemetryRequestBus::Broadcast(&TelemetryRequests::SetCaptureMask, fullCaptureMask);
-    }
-
-    static void FrameAdvancedTypeCvarChangedCallback(ICVar*)
-    {
-        TelemetryRequestBus::Broadcast(&TelemetryRequests::SetFrameAdvanceType, (s_frameAdvanceType == 0) ? FrameAdvanceType::Game : FrameAdvanceType::Render);
-    }
-
-    static void CmdTelemetryToggleEnabled([[maybe_unused]] IConsoleCmdArgs* args)
-    {
-        TelemetryRequestBus::Broadcast(&TelemetryRequests::SetAddress, s_telemetryAddress, s_telemetryPort);
-
-        FrameAdvancedTypeCvarChangedCallback(nullptr); // Set frame advance type
-        MaskCvarChangedCallback(nullptr); // Set the capture mask
-
-        TelemetryRequestBus::Broadcast(&TelemetryRequests::ToggleEnabled);
-    }
-#endif
-
-    class RADTelemetryModule
-        : public CryHooksModule
-    {
-    public:
-        AZ_RTTI(RADTelemetryModule, "{50BB63A6-4669-41F2-B93D-6EB8529413CD}", CryHooksModule);
-
-        RADTelemetryModule()
-            : CryHooksModule()
-        {
-#ifdef AZ_PROFILE_TELEMETRY
-            m_descriptors.insert(m_descriptors.end(), {
-                ProfileTelemetryComponent::CreateDescriptor(),
-            });
-#endif
-        }
-
-        /**
-         * Add required SystemComponents to the SystemEntity.
-         */
-        AZ::ComponentTypeList GetRequiredSystemComponents() const override
-        {
-            AZ::ComponentTypeList components;
-
-#ifdef AZ_PROFILE_TELEMETRY
-            components.insert(components.end(),
-                azrtti_typeid<ProfileTelemetryComponent>()
-            );
-#endif
-
-            return components;
-        }
-
-        void OnCrySystemInitialized(ISystem& system, const SSystemInitParams& initParams) override
-        {
-            CryHooksModule::OnCrySystemInitialized(system, initParams);
-            
-#ifdef AZ_PROFILE_TELEMETRY
-            REGISTER_COMMAND("radtm_ToggleEnabled", &CmdTelemetryToggleEnabled, 0, "Enabled or Disable RAD Telemetry");
-
-            REGISTER_CVAR2("radtm_Address", &s_telemetryAddress, "127.0.0.1", VF_NULL, "The IP address for the telemetry server");
-            REGISTER_CVAR2("radtm_Port", &s_telemetryPort, 4719, VF_NULL, "The port for the RAD telemetry server");
-            REGISTER_CVAR2("radtm_MemoryCaptureEnabled", &s_memCaptureEnabled, 0, VF_NULL, "Toggle for telemetry memory capture");
-
-            const int defaultFrameAdvanceTypeCvarValue = (FrameAdvanceType::Default == FrameAdvanceType::Game) ? 0 : 1;
-            REGISTER_CVAR2_CB("radtm_FrameAdvanceType", &s_frameAdvanceType, defaultFrameAdvanceTypeCvarValue, VF_NULL, "Advance profile frames from either: =0 the main thread, or =1 render frame advance", FrameAdvancedTypeCvarChangedCallback);
-
-            // Get the default value from ProfileTelemetryComponent
-            MaskType defaultCaptureMaskValue = 0;
-            TelemetryRequestBus::BroadcastResult(defaultCaptureMaskValue, &TelemetryRequests::GetCaptureMask);
-
-            char defaultCaptureMaskStr[19];
-            azsnprintf(defaultCaptureMaskStr, AZ_ARRAY_SIZE(defaultCaptureMaskStr), "0x%" PRIx64, defaultCaptureMaskValue);
-            REGISTER_CVAR2_CB("radtm_CaptureMask", &s_telemetryCaptureMask, defaultCaptureMaskStr, VF_NULL, "A hex bitmask for the categories to be captured, 0x0 for all", MaskCvarChangedCallback);
-#endif
-        }
-    };
-}
-
-// DO NOT MODIFY THIS LINE UNLESS YOU RENAME THE GEM
-// The first parameter should be GemName_GemIdLower
-// The second should be the fully qualified name of the class above
-AZ_DECLARE_MODULE_CLASS(Gem_RADTelemetry, RADTelemetry::RADTelemetryModule)
diff --git a/Gems/RADTelemetry/Code/radtelemetry_files.cmake b/Gems/RADTelemetry/Code/radtelemetry_files.cmake
deleted file mode 100644
index 2efee83797..0000000000
--- a/Gems/RADTelemetry/Code/radtelemetry_files.cmake
+++ /dev/null
@@ -1,12 +0,0 @@
-#
-# Copyright (c) Contributors to the Open 3D Engine Project.
-# For complete copyright and license terms please see the LICENSE at the root of this distribution.
-#
-# SPDX-License-Identifier: Apache-2.0 OR MIT
-#
-#
-
-set(FILES
-    Source/ProfileTelemetryComponent.cpp
-    Source/ProfileTelemetryComponent.h
-)
diff --git a/Gems/RADTelemetry/Code/radtelemetry_shared_files.cmake b/Gems/RADTelemetry/Code/radtelemetry_shared_files.cmake
deleted file mode 100644
index 9b07af44d4..0000000000
--- a/Gems/RADTelemetry/Code/radtelemetry_shared_files.cmake
+++ /dev/null
@@ -1,11 +0,0 @@
-#
-# Copyright (c) Contributors to the Open 3D Engine Project.
-# For complete copyright and license terms please see the LICENSE at the root of this distribution.
-#
-# SPDX-License-Identifier: Apache-2.0 OR MIT
-#
-#
-
-set(FILES
-    Source/RADTelemetryModule.cpp
-)
diff --git a/Gems/RADTelemetry/gem.json b/Gems/RADTelemetry/gem.json
deleted file mode 100644
index 932093b4a9..0000000000
--- a/Gems/RADTelemetry/gem.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-    "gem_name": "RADTelemetry",
-    "display_name": "RAD Telemetry",
-    "license": "Apache-2.0 Or MIT",
-    "origin": "Open 3D Engine - o3de.org",
-    "type": "Tool",
-    "summary": "The RAD Telemetry Gem provides support for RAD Telemetry, a performance profiling and visualization middleware, in Open 3D Engine.",
-    "canonical_tags": ["Gem"],
-    "user_tags": ["Debug", "SDK"],
-    "icon_path": "preview.png",
-    "requirements": "",
-    "documentation_url": "https://o3de.org/docs/user-guide/gems/reference/debug/rad/rad-telemetry/"
-}
diff --git a/Gems/RADTelemetry/preview.png b/Gems/RADTelemetry/preview.png
deleted file mode 100644
index 2f1ed47754..0000000000
--- a/Gems/RADTelemetry/preview.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6d6204c6730e5675791765ca194e9b1cbec282208e280507de830afc2805e5fa
-size 41127
diff --git a/cmake/3rdParty/Platform/Android/RadTelemetry_android.cmake b/cmake/3rdParty/Platform/Android/RadTelemetry_android.cmake
deleted file mode 100644
index 658c9440b2..0000000000
--- a/cmake/3rdParty/Platform/Android/RadTelemetry_android.cmake
+++ /dev/null
@@ -1,9 +0,0 @@
-#
-# Copyright (c) Contributors to the Open 3D Engine Project.
-# For complete copyright and license terms please see the LICENSE at the root of this distribution.
-#
-# SPDX-License-Identifier: Apache-2.0 OR MIT
-#
-#
-
-set(RADTELEMETRY_LIBS ${BASE_PATH}/Lib/librad_tm_android_arm64.a)
diff --git a/cmake/3rdParty/Platform/Mac/RadTelemetry_mac.cmake b/cmake/3rdParty/Platform/Mac/RadTelemetry_mac.cmake
deleted file mode 100644
index 572d798868..0000000000
--- a/cmake/3rdParty/Platform/Mac/RadTelemetry_mac.cmake
+++ /dev/null
@@ -1,11 +0,0 @@
-#
-# Copyright (c) Contributors to the Open 3D Engine Project.
-# For complete copyright and license terms please see the LICENSE at the root of this distribution.
-#
-# SPDX-License-Identifier: Apache-2.0 OR MIT
-#
-#
-
-set(RADTELEMETRY_LIBS ${BASE_PATH}/Lib/librad_tm_mac_x64_link.a)
-
-set(RADTELEMETRY_RUNTIME_DEPENDENCIES ${BASE_PATH}/Lib/librad_tm_mac_x64.dylib)
diff --git a/cmake/3rdParty/Platform/Windows/RadTelemetry_windows.cmake b/cmake/3rdParty/Platform/Windows/RadTelemetry_windows.cmake
deleted file mode 100644
index 1caa62e5c5..0000000000
--- a/cmake/3rdParty/Platform/Windows/RadTelemetry_windows.cmake
+++ /dev/null
@@ -1,11 +0,0 @@
-#
-# Copyright (c) Contributors to the Open 3D Engine Project.
-# For complete copyright and license terms please see the LICENSE at the root of this distribution.
-#
-# SPDX-License-Identifier: Apache-2.0 OR MIT
-#
-#
-
-set(RADTELEMETRY_LIBS ${BASE_PATH}/Lib/rad_tm_win64.lib)
-
-set(RADTELEMETRY_RUNTIME_DEPENDENCIES ${BASE_PATH}/Dll/rad_tm_win64.dll)
diff --git a/cmake/3rdParty/Platform/iOS/RadTelemetry_ios.cmake b/cmake/3rdParty/Platform/iOS/RadTelemetry_ios.cmake
deleted file mode 100644
index 0da6750cbe..0000000000
--- a/cmake/3rdParty/Platform/iOS/RadTelemetry_ios.cmake
+++ /dev/null
@@ -1,9 +0,0 @@
-#
-# Copyright (c) Contributors to the Open 3D Engine Project.
-# For complete copyright and license terms please see the LICENSE at the root of this distribution.
-#
-# SPDX-License-Identifier: Apache-2.0 OR MIT
-#
-#
-
-set(RADTELEMETRY_LIBS ${BASE_PATH}/Lib/librad_tm_ios.a)
diff --git a/engine.json b/engine.json
index 5d862779c0..29532347db 100644
--- a/engine.json
+++ b/engine.json
@@ -62,7 +62,6 @@
         "Gems/PrimitiveAssets",
         "Gems/PythonAssetBuilder",
         "Gems/QtForPython",
-        "Gems/RADTelemetry",
         "Gems/SaveData",
         "Gems/SceneLoggingExample",
         "Gems/SceneProcessing",

From f1349a3f60d8ce23802a14d8d028a9764972dcf9 Mon Sep 17 00:00:00 2001
From: Jeremy Ong <jcong@amazon.com>
Date: Wed, 18 Aug 2021 17:31:28 -0600
Subject: [PATCH 32/37] Clean up vestigial PIX references in Atom

Signed-off-by: Jeremy Ong <jcong@amazon.com>
---
 Code/Framework/AzCore/Tests/TimeDataStatistics.cpp     |  4 ++--
 Gems/Atom/RHI/DX12/Code/CMakeLists.txt                 | 10 ----------
 .../Code/Source/Platform/Windows/PAL_windows.cmake     |  1 -
 Gems/Atom/RHI/DX12/Code/Source/RHI/Fence.h             |  2 ++
 4 files changed, 4 insertions(+), 13 deletions(-)

diff --git a/Code/Framework/AzCore/Tests/TimeDataStatistics.cpp b/Code/Framework/AzCore/Tests/TimeDataStatistics.cpp
index f75d401c1f..21b42fc451 100644
--- a/Code/Framework/AzCore/Tests/TimeDataStatistics.cpp
+++ b/Code/Framework/AzCore/Tests/TimeDataStatistics.cpp
@@ -200,9 +200,9 @@ namespace UnitTest
 
     // TODO:BUDGETS disabled until profiler budgets system comes online
     // TEST_F(TimeDataStatisticsManagerTest, Test)
-    {
+    // {
         // run();
-    }
+    // }
     //End of all Tests of TimeDataStatisticsManagerTest
 
 }//namespace UnitTest
diff --git a/Gems/Atom/RHI/DX12/Code/CMakeLists.txt b/Gems/Atom/RHI/DX12/Code/CMakeLists.txt
index 8670efa7e6..b913ad58bf 100644
--- a/Gems/Atom/RHI/DX12/Code/CMakeLists.txt
+++ b/Gems/Atom/RHI/DX12/Code/CMakeLists.txt
@@ -11,13 +11,6 @@ ly_get_list_relative_pal_filename(pal_source_dir ${CMAKE_CURRENT_LIST_DIR}/Sourc
 
 include(${pal_source_dir}/PAL_${PAL_PLATFORM_NAME_LOWERCASE}.cmake) # PAL_TRAIT_ATOM_RHI_DX12_SUPPORTED
 
-if(PAL_TRAIT_PIX_AVAILABLE)
-    set(PIX_BUILD_DEPENDENCY "3rdParty::pix")
-else()
-    set(PIX_BUILD_DEPENDENCY "")
-endif()
-
-
 if(PAL_TRAIT_AFTERMATH_AVAILABLE)
     set(USE_NSIGHT_AFTERMATH_DEFINE $<IF:$<CONFIG:release>,"","USE_NSIGHT_AFTERMATH">)
     set(AFTERMATH_BUILD_DEPENDENCY "3rdParty::Aftermath")
@@ -90,7 +83,6 @@ ly_add_target(
     BUILD_DEPENDENCIES
         PRIVATE
             AZ::AzCore
-            ${PIX_BUILD_DEPENDENCY}
             Gem::Atom_RHI.Reflect
 )
 
@@ -116,7 +108,6 @@ ly_add_target(
             Gem::Atom_RHI_DX12.Reflect
             3rdParty::d3dx12
             ${AFTERMATH_BUILD_DEPENDENCY}           
-            ${PIX_BUILD_DEPENDENCY}
     COMPILE_DEFINITIONS 
         PRIVATE
             ${USE_NSIGHT_AFTERMATH_DEFINE}
@@ -142,7 +133,6 @@ ly_add_target(
             Gem::Atom_RHI.Public
             Gem::Atom_RHI_DX12.Reflect
             Gem::Atom_RHI_DX12.Private.Static
-            ${PIX_BUILD_DEPENDENCY}
 )
 
 if(PAL_TRAIT_BUILD_HOST_TOOLS)
diff --git a/Gems/Atom/RHI/DX12/Code/Source/Platform/Windows/PAL_windows.cmake b/Gems/Atom/RHI/DX12/Code/Source/Platform/Windows/PAL_windows.cmake
index b885e53ec0..eb733a4d5a 100644
--- a/Gems/Atom/RHI/DX12/Code/Source/Platform/Windows/PAL_windows.cmake
+++ b/Gems/Atom/RHI/DX12/Code/Source/Platform/Windows/PAL_windows.cmake
@@ -18,7 +18,6 @@ if(d3d12_dll)
     set(PAL_TRAIT_ATOM_RHI_DX12_SUPPORTED TRUE)
 endif()
 
-set(PAL_TRAIT_PIX_AVAILABLE FALSE)
 unset(pix3_header CACHE)
 
 set(PAL_TRAIT_AFTERMATH_AVAILABLE FALSE)
diff --git a/Gems/Atom/RHI/DX12/Code/Source/RHI/Fence.h b/Gems/Atom/RHI/DX12/Code/Source/RHI/Fence.h
index 133b8aa664..ab1a719ae6 100644
--- a/Gems/Atom/RHI/DX12/Code/Source/RHI/Fence.h
+++ b/Gems/Atom/RHI/DX12/Code/Source/RHI/Fence.h
@@ -7,6 +7,8 @@
  */
 #pragma once
 
+// NOTE: We are careful to include platform headers *before* we include AzCore/Debug/Profiler.h to ensure that d3d12 symbols
+// are defined prior to the inclusion of the pix3 runtime.
 #include <RHI/DX12.h>
 
 #include <Atom/RHI/Fence.h>

From cf44a4ad678b8ae7e2bf793d9c1d345db857feee Mon Sep 17 00:00:00 2001
From: Jeremy Ong <jcong@amazon.com>
Date: Wed, 18 Aug 2021 19:16:05 -0600
Subject: [PATCH 33/37] Address additional PR feedback

Signed-off-by: Jeremy Ong <jcong@amazon.com>
---
 .gitignore                                    |  1 -
 Code/Framework/AzCore/AzCore/Debug/Profiler.h |  4 +++-
 Code/Legacy/CryCommon/ProjectDefines.h        |  1 -
 .../ExpressionEvaluationSystemComponent.cpp   |  2 +-
 .../Code/Editor/Nodes/NodeCreateUtils.cpp     | 22 +++++++++----------
 5 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/.gitignore b/.gitignore
index e41b92498f..b73c89b1d9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,7 +3,6 @@
 .vscode/
 __pycache__
 AssetProcessorTemp/**
-CMakeUserPresets.json
 [Bb]uild/**
 [Oo]ut/**
 [Cc]ache/
diff --git a/Code/Framework/AzCore/AzCore/Debug/Profiler.h b/Code/Framework/AzCore/AzCore/Debug/Profiler.h
index 1d932031ef..f173bb8e17 100644
--- a/Code/Framework/AzCore/AzCore/Debug/Profiler.h
+++ b/Code/Framework/AzCore/AzCore/Debug/Profiler.h
@@ -58,13 +58,15 @@ namespace AZ
         static uint32_t GetSystemID(const char* system);
 
         template<typename... T>
-        static void BeginRegion([[maybe_unused]] const char* system, [[maybe_unused]] char const* eventName, [[maybe_unused]] T const&... args)
+        static void BeginRegion([[maybe_unused]] const char* system, [[maybe_unused]] const char* eventName, [[maybe_unused]] T const&... args)
         {
             // TODO: Verification that the supplied system name corresponds to a known budget
 #if defined(USE_PIX)
             PIXBeginEvent(PIX_COLOR_INDEX(GetSystemID(system) & 0xff), eventName, args...);
 #endif
             // TODO: injecting instrumentation for other profilers
+            // NOTE: external profiler registration won't occur inline in a header necessarily in this manner, but the exact mechanism
+            //       will be introduced in a future PR
         }
 
         static void EndRegion()
diff --git a/Code/Legacy/CryCommon/ProjectDefines.h b/Code/Legacy/CryCommon/ProjectDefines.h
index c7740db95c..f7f73f111b 100644
--- a/Code/Legacy/CryCommon/ProjectDefines.h
+++ b/Code/Legacy/CryCommon/ProjectDefines.h
@@ -173,7 +173,6 @@
 
 #if defined(ENABLE_PROFILING_CODE)
     #define USE_DISK_PROFILER
-    #define ENABLE_LOADING_PROFILER
 #endif
 
 // The maximum number of joints in an animation
diff --git a/Gems/ExpressionEvaluation/Code/Source/ExpressionEvaluationSystemComponent.cpp b/Gems/ExpressionEvaluation/Code/Source/ExpressionEvaluationSystemComponent.cpp
index 09b7bf878b..295d42228d 100644
--- a/Gems/ExpressionEvaluation/Code/Source/ExpressionEvaluationSystemComponent.cpp
+++ b/Gems/ExpressionEvaluation/Code/Source/ExpressionEvaluationSystemComponent.cpp
@@ -514,7 +514,7 @@ namespace ExpressionEvaluation
 
     ExpressionResult ExpressionEvaluationSystemComponent::Evaluate(const ExpressionTree& expressionTree) const
     {
-        AZ_PROFILE_SCOPE("ExpressionEvaluation", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ExpressionEvaluation);
 
         ExpressionResultStack resultStack;
 
diff --git a/Gems/ScriptCanvas/Code/Editor/Nodes/NodeCreateUtils.cpp b/Gems/ScriptCanvas/Code/Editor/Nodes/NodeCreateUtils.cpp
index bb3a28099e..3bcd940a01 100644
--- a/Gems/ScriptCanvas/Code/Editor/Nodes/NodeCreateUtils.cpp
+++ b/Gems/ScriptCanvas/Code/Editor/Nodes/NodeCreateUtils.cpp
@@ -99,7 +99,7 @@ namespace ScriptCanvasEditor::Nodes
 
     AZStd::pair<ScriptCanvas::Node*, NodeIdPair> CreateAndGetNode(const AZ::Uuid& classId, const ScriptCanvas::ScriptCanvasId& scriptCanvasId, const StyleConfiguration& styleConfiguration, AZStd::function<void(ScriptCanvas::Node*)> onCreateCallback)
     {
-        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
         NodeIdPair nodeIdPair;
 
         ScriptCanvas::Node* node{};
@@ -134,7 +134,7 @@ namespace ScriptCanvasEditor::Nodes
 
     NodeIdPair CreateObjectMethodNode(AZStd::string_view className, AZStd::string_view methodName, const ScriptCanvas::ScriptCanvasId& scriptCanvasId, ScriptCanvas::PropertyStatus propertyStatus)
     {
-        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
         NodeIdPair nodeIds;
 
         ScriptCanvas::Node* node = nullptr;
@@ -161,7 +161,7 @@ namespace ScriptCanvasEditor::Nodes
 
     NodeIdPair CreateObjectMethodOverloadNode(AZStd::string_view className, AZStd::string_view methodName, const ScriptCanvas::ScriptCanvasId& scriptCanvasGraphId)
     {
-        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
         NodeIdPair nodeIds;
 
         ScriptCanvas::Node* node = nullptr;
@@ -188,7 +188,7 @@ namespace ScriptCanvasEditor::Nodes
 
     NodeIdPair CreateGlobalMethodNode(AZStd::string_view methodName, const ScriptCanvas::ScriptCanvasId& scriptCanvasId)
     {
-        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
         NodeIdPair nodeIds;
 
         ScriptCanvas::Node* node = nullptr;
@@ -215,7 +215,7 @@ namespace ScriptCanvasEditor::Nodes
 
     NodeIdPair CreateEbusWrapperNode(AZStd::string_view busName, const ScriptCanvas::ScriptCanvasId& scriptCanvasId)
     {
-        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
         NodeIdPair nodeIdPair;
 
         ScriptCanvas::Node* node = nullptr;
@@ -241,7 +241,7 @@ namespace ScriptCanvasEditor::Nodes
     {
         AZ_Assert(assetId.IsValid(), "CreateScriptEventReceiverNode asset Id must be valid");
 
-        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
         NodeIdPair nodeIdPair;
 
         AZ::Data::Asset<ScriptEvents::ScriptEventsAsset> asset = AZ::Data::AssetManager::Instance().GetAsset<ScriptEvents::ScriptEventsAsset>(assetId, AZ::Data::AssetLoadBehavior::Default);
@@ -276,7 +276,7 @@ namespace ScriptCanvasEditor::Nodes
     {
         AZ_Assert(assetId.IsValid(), "CreateScriptEventSenderNode asset Id must be valid");
 
-        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
         NodeIdPair nodeIdPair;
 
         AZ::Data::Asset<ScriptEvents::ScriptEventsAsset> asset = AZ::Data::AssetManager::Instance().GetAsset<ScriptEvents::ScriptEventsAsset>(assetId, AZ::Data::AssetLoadBehavior::Default);
@@ -302,7 +302,7 @@ namespace ScriptCanvasEditor::Nodes
 
     NodeIdPair CreateGetVariableNode(const ScriptCanvas::VariableId& variableId, ScriptCanvas::ScriptCanvasId scriptCanvasId)
     {
-        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
         const AZ::Uuid k_VariableNodeTypeId = azrtti_typeid<ScriptCanvas::Nodes::Core::GetVariableNode>();
 
         NodeIdPair nodeIds;
@@ -333,7 +333,7 @@ namespace ScriptCanvasEditor::Nodes
 
     NodeIdPair CreateSetVariableNode(const ScriptCanvas::VariableId& variableId, ScriptCanvas::ScriptCanvasId scriptCanvasId)
     {
-        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
         const AZ::Uuid k_VariableNodeTypeId = azrtti_typeid<ScriptCanvas::Nodes::Core::SetVariableNode>();
 
         NodeIdPair nodeIds;
@@ -366,7 +366,7 @@ namespace ScriptCanvasEditor::Nodes
     {
         AZ_Assert(assetId.IsValid(), "CreateFunctionNode source asset Id must be valid");
 
-        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
         NodeIdPair nodeIdPair;
 
         AZ::Data::Asset<ScriptCanvas::SubgraphInterfaceAsset> asset = AZ::Data::AssetManager::Instance().GetAsset<ScriptCanvas::SubgraphInterfaceAsset>(assetId, AZ::Data::AssetLoadBehavior::PreLoad);
@@ -394,7 +394,7 @@ namespace ScriptCanvasEditor::Nodes
     NodeIdPair CreateAzEventHandlerNode(const AZ::BehaviorMethod& methodWithAzEventReturn, ScriptCanvas::ScriptCanvasId scriptCanvasId,
         AZ::EntityId connectingMethodNodeId)
     {
-        AZ_PROFILE_SCOPE("ScriptCanvas", __FUNCTION__);
+        AZ_PROFILE_FUNCTION(ScriptCanvas);
         NodeIdPair nodeIdPair;
 
         // Make sure the method returns an AZ::Event by reference or pointer

From 586678a5f97fdf8b752f27da32d276b6ad067d06 Mon Sep 17 00:00:00 2001
From: lumberyard-employee-dm
 <56135373+lumberyard-employee-dm@users.noreply.github.com>
Date: Wed, 18 Aug 2021 20:58:57 -0500
Subject: [PATCH 34/37] Added a deferred queue to the AZ Console class (#3298)

* Added a deferred queue to the AZ Console class

An AZ Console instance will now store any console commands that could be
dispatched from a configuration file into a deferred queue, that can be
invoked later.

This can be used to defer execution of console commands in configuration files such as
.cfg, .setreg and .setregpatch files that are defined in gem modules that
have not been loaded yet.
The defered execution can then be invoked at any point later in the
application

Updated the Component Application CreateCommon function to invoke deferred console commands
after all the gems have loaded

fixes #2062

Signed-off-by: lumberyard-employee-dm <56135373+lumberyard-employee-dm@users.noreply.github.com>

* Fixed variable shadowing in the Console Deferred Command Test

Updated commit for the ClearDeferredQueue function to just mention
clearing the queue

Signed-off-by: lumberyard-employee-dm <56135373+lumberyard-employee-dm@users.noreply.github.com>

* Filtered out execution of the ConsoleRootCommandKey as a console command

The AZ::Console notification handler is tracking changes to the fields
of "/Amazon/AzCore/Runtime/ConsoleCommands" and it's children.

Now the "/Amazon/AzCore/Runtime/ConsoleCommands" field is the
ConsoleRootCommandKey and not an actual console command so it shouldn't
attempt to be invoked

Signed-off-by: lumberyard-employee-dm <56135373+lumberyard-employee-dm@users.noreply.github.com>

* Moved the execution of deferred console commands after linking deferred
functors

Signed-off-by: lumberyard-employee-dm <56135373+lumberyard-employee-dm@users.noreply.github.com>

* Moved the execution of deferred console commands into CreateModuleClass
hook

Any module that loads using the ModuleManager system will attempt to
execute any deferred console commands to allow newly registered commands
from that module to be dispatched.

Signed-off-by: lumberyard-employee-dm <56135373+lumberyard-employee-dm@users.noreply.github.com>
---
 .../AzCore/AzCore/Console/Console.cpp         | 50 ++++++++++++---
 .../Framework/AzCore/AzCore/Console/Console.h | 23 ++++++-
 .../AzCore/AzCore/Console/IConsole.h          | 18 ++++--
 Code/Framework/AzCore/AzCore/Module/Module.h  | 15 +++--
 .../AzCore/Tests/Console/ConsoleTests.cpp     | 64 +++++++++++++++++++
 5 files changed, 149 insertions(+), 21 deletions(-)

diff --git a/Code/Framework/AzCore/AzCore/Console/Console.cpp b/Code/Framework/AzCore/AzCore/Console/Console.cpp
index 8bb50f77e0..016bd86e46 100644
--- a/Code/Framework/AzCore/AzCore/Console/Console.cpp
+++ b/Code/Framework/AzCore/AzCore/Console/Console.cpp
@@ -174,12 +174,28 @@ namespace AZ
         }
     }
 
-    bool Console::HasCommand(const char* command)
+    bool Console::ExecuteDeferredConsoleCommands()
+    {
+        auto DeferredCommandCallable = [this](const DeferredCommand& deferredCommand)
+        {
+            return this->DispatchCommand(deferredCommand.m_command, deferredCommand.m_arguments, deferredCommand.m_silentMode,
+                deferredCommand.m_invokedFrom, deferredCommand.m_requiredSet, deferredCommand.m_requiredClear);
+        };
+        // Attempt to invoke the deferred command and remove it from the queue if successful
+        return AZStd::erase_if(m_deferredCommands, DeferredCommandCallable) != 0;
+    }
+
+    void Console::ClearDeferredConsoleCommands()
+    {
+        m_deferredCommands = {};
+    }
+
+    bool Console::HasCommand(AZStd::string_view command)
     {
         return FindCommand(command) != nullptr;
     }
 
-    ConsoleFunctorBase* Console::FindCommand(const char* command)
+    ConsoleFunctorBase* Console::FindCommand(AZStd::string_view command)
     {
         CVarFixedString lowerName(command);
         AZStd::transform(lowerName.begin(), lowerName.end(), lowerName.begin(), [](char value) { return std::tolower(value); });
@@ -200,11 +216,9 @@ namespace AZ
         return nullptr;
     }
 
-    AZStd::string Console::AutoCompleteCommand(const char* command, AZStd::vector<AZStd::string>* matches)
+    AZStd::string Console::AutoCompleteCommand(AZStd::string_view command, AZStd::vector<AZStd::string>* matches)
     {
-        const size_t commandLength = strlen(command);
-
-        if (commandLength <= 0)
+        if (command.empty())
         {
             return command;
         }
@@ -219,7 +233,7 @@ namespace AZ
                 continue;
             }
 
-            if (StringFunc::Equal(curr->m_name, command, false, commandLength))
+            if (StringFunc::StartsWith(curr->m_name, command, false))
             {
                 AZLOG_INFO("- %s : %s\n", curr->m_name, curr->m_desc);
                 commandSubset.push_back(curr->m_name);
@@ -498,7 +512,8 @@ namespace AZ
 
             AZ::IO::PathView consoleRootCommandKey{ IConsole::ConsoleRootCommandKey, AZ::IO::PosixPathSeparator };
             AZ::IO::PathView inputKey{ path, AZ::IO::PosixPathSeparator };
-            if (inputKey.IsRelativeTo(consoleRootCommandKey))
+            // The ConsoleRootComamndKey is not a command itself so strictly children keys are being examined
+            if (inputKey.IsRelativeTo(consoleRootCommandKey) && inputKey != consoleRootCommandKey)
             {
                 FixedValueString command = inputKey.LexicallyRelative(consoleRootCommandKey).Native();
                 ConsoleCommandContainer commandArgs;
@@ -560,7 +575,24 @@ namespace AZ
                     commandTrace += commandArg;
                 }
 
-                m_console.PerformCommand(command, commandArgs, ConsoleSilentMode::NotSilent, ConsoleInvokedFrom::AzConsole, ConsoleFunctorFlags::Null, ConsoleFunctorFlags::Null);
+                if (!m_console.PerformCommand(command, commandArgs, ConsoleSilentMode::NotSilent,
+                    ConsoleInvokedFrom::AzConsole, ConsoleFunctorFlags::Null, ConsoleFunctorFlags::Null))
+                {
+                    // If the command could not be dispatched at this time add it to the
+                    // deferred commands queue
+                    using DeferredCommand = Console::DeferredCommand;
+                    DeferredCommand deferredCommand
+                    {
+                        AZStd::string_view{command},
+                        DeferredCommand::DeferredArguments{commandArgs.begin(), commandArgs.end()},
+                        ConsoleSilentMode::NotSilent,
+                        ConsoleInvokedFrom::AzConsole,
+                        ConsoleFunctorFlags::Null,
+                        ConsoleFunctorFlags::Null
+                    };
+
+                    m_console.m_deferredCommands.emplace_back(AZStd::move(deferredCommand));
+                }
             }
         }
 
diff --git a/Code/Framework/AzCore/AzCore/Console/Console.h b/Code/Framework/AzCore/AzCore/Console/Console.h
index dbcf2b116f..0edda9f531 100644
--- a/Code/Framework/AzCore/AzCore/Console/Console.h
+++ b/Code/Framework/AzCore/AzCore/Console/Console.h
@@ -60,9 +60,13 @@ namespace AZ
         ) override;
         void ExecuteConfigFile(AZStd::string_view configFileName) override;
         void ExecuteCommandLine(const AZ::CommandLine& commandLine) override;
-        bool HasCommand(const char* command) override;
-        ConsoleFunctorBase* FindCommand(const char* command) override;
-        AZStd::string AutoCompleteCommand(const char* command, AZStd::vector<AZStd::string>* matches = nullptr) override;
+        bool ExecuteDeferredConsoleCommands() override;
+
+        void ClearDeferredConsoleCommands() override;
+
+        bool HasCommand(AZStd::string_view command) override;
+        ConsoleFunctorBase* FindCommand(AZStd::string_view command) override;
+        AZStd::string AutoCompleteCommand(AZStd::string_view command, AZStd::vector<AZStd::string>* matches = nullptr) override;
         void VisitRegisteredFunctors(const FunctorVisitor& visitor) override;
         void RegisterFunctor(ConsoleFunctorBase* functor) override;
         void UnregisterFunctor(ConsoleFunctorBase* functor) override;
@@ -98,7 +102,20 @@ namespace AZ
         using CommandMap = AZStd::unordered_map<CVarFixedString, AZStd::vector<ConsoleFunctorBase*>>;
         CommandMap m_commands;
         AZ::SettingsRegistryInterface::NotifyEventHandler m_consoleCommandKeyHandler;
+        struct DeferredCommand
+        {
+            using DeferredArguments = AZStd::vector<AZStd::string>;
+            AZStd::string m_command;
+            DeferredArguments m_arguments;
+            ConsoleSilentMode m_silentMode;
+            ConsoleInvokedFrom m_invokedFrom;
+            ConsoleFunctorFlags m_requiredSet;
+            ConsoleFunctorFlags m_requiredClear;
+        };
+        using DeferredCommandQueue = AZStd::deque<DeferredCommand>;
+        DeferredCommandQueue m_deferredCommands;
 
+        friend struct ConsoleCommandKeyNotificationHandler;
         friend class ConsoleFunctorBase;
     };
 }
diff --git a/Code/Framework/AzCore/AzCore/Console/IConsole.h b/Code/Framework/AzCore/AzCore/Console/IConsole.h
index ee2b2bd0fb..dafc284ce3 100644
--- a/Code/Framework/AzCore/AzCore/Console/IConsole.h
+++ b/Code/Framework/AzCore/AzCore/Console/IConsole.h
@@ -94,22 +94,30 @@ namespace AZ
         //! @param commandLine the concatenated command-line string to execute
         virtual void ExecuteCommandLine(const AZ::CommandLine& commandLine) = 0;
 
+        //! Attempts to invoke a "deferred console command", which is a console command
+        //! that has failed to execute previously due to the command not being registered yet.
+        //! @return boolean true if any deferred console commands have executed, false otherwise
+        virtual bool ExecuteDeferredConsoleCommands() = 0;
+
+        //! Clear out any deferred console commands queue
+        virtual void ClearDeferredConsoleCommands() = 0;
+
         //! HasCommand is used to determine if the console knows about a command.
         //! @param command the command we are checking for
         //! @return boolean true on if the command is registered, false otherwise
-        virtual bool HasCommand(const char* command) = 0;
+        virtual bool HasCommand(AZStd::string_view command) = 0;
 
         //! FindCommand finds the console command with the specified console string.
         //! @param command the command that is being searched for
         //! @return non-null pointer to the console command if found
-        virtual ConsoleFunctorBase* FindCommand(const char* command) = 0;
+        virtual ConsoleFunctorBase* FindCommand(AZStd::string_view command) = 0;
 
         //! Finds all commands where the input command is a prefix and returns
         //! the longest matching substring prefix the results have in common.
         //! @param command The prefix string to find all matching commands for.
         //! @param matches The list of all commands that match the input prefix.
         //! @return The longest matching substring prefix the results have in common.
-        virtual AZStd::string AutoCompleteCommand(const char* command,
+        virtual AZStd::string AutoCompleteCommand(AZStd::string_view command,
                                                   AZStd::vector<AZStd::string>* matches = nullptr) = 0;
 
         //! Retrieves the value of the requested cvar.
@@ -117,7 +125,7 @@ namespace AZ
         //! @param outValue reference to the instance to write the current cvar value to
         //! @return GetValueResult::Success if the operation succeeded, or an error result if the operation failed
         template<typename RETURN_TYPE>
-        GetValueResult GetCvarValue(const char* command, RETURN_TYPE& outValue);
+        GetValueResult GetCvarValue(AZStd::string_view command, RETURN_TYPE& outValue);
 
         //! Visits all registered console functors.
         //! @param visitor the instance to visit all functors with
@@ -176,7 +184,7 @@ namespace AZ
     }
 
     template<typename RETURN_TYPE>
-    inline GetValueResult IConsole::GetCvarValue(const char* command, RETURN_TYPE& outValue)
+    inline GetValueResult IConsole::GetCvarValue(AZStd::string_view command, RETURN_TYPE& outValue)
     {
         ConsoleFunctorBase* cvarFunctor = FindCommand(command);
         if (cvarFunctor == nullptr)
diff --git a/Code/Framework/AzCore/AzCore/Module/Module.h b/Code/Framework/AzCore/AzCore/Module/Module.h
index 2c87b4f0fb..fb651e58a0 100644
--- a/Code/Framework/AzCore/AzCore/Module/Module.h
+++ b/Code/Framework/AzCore/AzCore/Module/Module.h
@@ -98,19 +98,26 @@ namespace AZ
 ///
 /// \param MODULE_NAME      Name of module.
 /// \param MODULE_CLASSNAME Name of AZ::Module class (include namespace).
+///
+/// Execute any deferred console commands after linking any new deferred functors
+/// This allows deferred console commands defined within the module to now execute
+/// at this point now that the module has been loaded
 #if defined(AZ_MONOLITHIC_BUILD)
 #   define AZ_DECLARE_MODULE_CLASS(MODULE_NAME, MODULE_CLASSNAME) \
     extern "C" AZ::Module * CreateModuleClass_##MODULE_NAME() { return aznew MODULE_CLASSNAME; }
 #else
 #   define AZ_DECLARE_MODULE_CLASS(MODULE_NAME, MODULE_CLASSNAME)                                \
     AZ_DECLARE_MODULE_INITIALIZATION                                                             \
-    extern "C" AZ_DLL_EXPORT AZ::Module * CreateModuleClass()                                    \
+    extern "C" AZ_DLL_EXPORT AZ::Module* CreateModuleClass()                                     \
     {                                                                                            \
-        AZ::ConsoleFunctorBase*& deferredHead = AZ::ConsoleFunctorBase::GetDeferredHead();       \
-        AZ::Interface<AZ::IConsole>::Get()->LinkDeferredFunctors(deferredHead);                  \
+        if (auto console = AZ::Interface<AZ::IConsole>::Get(); console != nullptr)               \
+        {                                                                                        \
+             console->LinkDeferredFunctors(AZ::ConsoleFunctorBase::GetDeferredHead());           \
+             console->ExecuteDeferredConsoleCommands();                                          \
+        }                                                                                        \
         return aznew MODULE_CLASSNAME;                                                           \
     }                                                                                            \
-    extern "C" AZ_DLL_EXPORT void DestroyModuleClass(AZ::Module * module) { delete module; }
+    extern "C" AZ_DLL_EXPORT void DestroyModuleClass(AZ::Module* module) { delete module; }
 #endif
 
 #endif // AZCORE_MODULE_INCLUDE_H
diff --git a/Code/Framework/AzCore/Tests/Console/ConsoleTests.cpp b/Code/Framework/AzCore/Tests/Console/ConsoleTests.cpp
index 3a56772b3c..d91ec5ba58 100644
--- a/Code/Framework/AzCore/Tests/Console/ConsoleTests.cpp
+++ b/Code/Framework/AzCore/Tests/Console/ConsoleTests.cpp
@@ -507,6 +507,70 @@ namespace ConsoleSettingsRegistryTests
         AZ::Interface<AZ::IConsole>::Unregister(&testConsole);
     }
 
+    template<typename T>
+    using ConsoleDataWrapper = AZ::ConsoleDataWrapper<T, ConsoleThreadSafety<T>>;
+    TEST_P(ConsoleSettingsRegistryFixture, Console_RecordsUnregisteredCommands_And_IsAbleToDeferDispatchCommand_Successfully)
+    {
+        AZ::Console testConsole(*m_registry);
+        AZ::Interface<AZ::IConsole>::Register(&testConsole);
+        // GetDeferredHead is invoked for the side effect of to set the s_deferredHeadInvoked value to true
+        // This allows scoped console variables to be attached immediately
+        [[maybe_unused]] auto deferredHead = AZ::ConsoleFunctorBase::GetDeferredHead();
+
+
+        ConsoleDataWrapper<int32_t> localTestInit{ {}, nullptr, "testInit", "", AZ::ConsoleFunctorFlags::Null };
+        ConsoleDataWrapper<char> localTestChar{ {}, nullptr, "testChar", "", AZ::ConsoleFunctorFlags::Null };
+        ConsoleDataWrapper<bool> localTestBool{ {}, nullptr, "testBool", "", AZ::ConsoleFunctorFlags::Null };
+
+        s_consoleFreeFunctionInvoked = false;
+
+        // Invoke the Commands for Scoped CVar variables above
+        auto configFileParams = GetParam();
+        auto testFilePath = m_testFolder / configFileParams.m_testConfigFileName;
+        EXPECT_TRUE(AZ::IO::SystemFile::Exists(testFilePath.c_str()));
+        testConsole.ExecuteConfigFile(testFilePath.Native());
+
+        EXPECT_EQ(3, localTestInit);
+        EXPECT_TRUE(static_cast<bool>(localTestBool));
+        EXPECT_EQ('Q', localTestChar);
+
+        // The following commands from the config files should have been deferred
+        ConsoleDataWrapper<int8_t> localTestInt8{ {}, nullptr, "testInt8", "", AZ::ConsoleFunctorFlags::Null };
+        ConsoleDataWrapper<int16_t> localTestInt16{ {}, nullptr, "testInt16", "", AZ::ConsoleFunctorFlags::Null };
+        ConsoleDataWrapper<int32_t> localTestInt32{ {}, nullptr, "testInt32", "", AZ::ConsoleFunctorFlags::Null };
+        ConsoleDataWrapper<int64_t> localTestInt64{ {}, nullptr, "testInt64", "", AZ::ConsoleFunctorFlags::Null };
+        ConsoleDataWrapper<uint8_t> localTestUInt8{ {}, nullptr, "testUInt8", "", AZ::ConsoleFunctorFlags::Null };
+        ConsoleDataWrapper<uint16_t> localTestUInt16{ {}, nullptr, "testUInt16", "", AZ::ConsoleFunctorFlags::Null };
+        ConsoleDataWrapper<uint32_t> localTestUInt32{ {}, nullptr, "testUInt32", "", AZ::ConsoleFunctorFlags::Null };
+        ConsoleDataWrapper<uint64_t> localTestUInt64{ {}, nullptr, "testUInt64", "", AZ::ConsoleFunctorFlags::Null };
+        ConsoleDataWrapper<float> localTestFloat{ {}, nullptr, "testFloat", "", AZ::ConsoleFunctorFlags::Null };
+        ConsoleDataWrapper<double> localTestDouble{ {}, nullptr, "testDouble", "", AZ::ConsoleFunctorFlags::Null };
+        ConsoleDataWrapper<AZ::CVarFixedString> localTestString{ {}, nullptr, "testString", "", AZ::ConsoleFunctorFlags::Null };
+
+
+        // The scoped cvars just above should have all been deferred for execution
+        // Each of them should have executed resulting in the expected return value
+        EXPECT_TRUE(testConsole.ExecuteDeferredConsoleCommands());
+
+        EXPECT_EQ(24, localTestInt8);
+        EXPECT_EQ(-32, localTestInt16);
+        EXPECT_EQ(41, localTestInt32);
+        EXPECT_EQ(-51, localTestInt64);
+        EXPECT_EQ(3, localTestUInt8);
+        EXPECT_EQ(5, localTestUInt16);
+        EXPECT_EQ(6, localTestUInt32);
+        EXPECT_EQ(0xFFFF'FFFF'FFFF'FFFF, localTestUInt64);
+        EXPECT_FLOAT_EQ(1.0f, localTestFloat);
+        EXPECT_DOUBLE_EQ(2, localTestDouble);
+        EXPECT_STREQ("Stable", static_cast<AZ::CVarFixedString>(localTestString).c_str());
+
+        // All of the deferred console commands should have executed at this point
+        // Therefore this invocation should return false
+        EXPECT_FALSE(testConsole.ExecuteDeferredConsoleCommands());
+
+        AZ::Interface<AZ::IConsole>::Unregister(&testConsole);
+    }
+
 
     static constexpr AZStd::string_view UserINIStyleContent =
         R"(

From 80e08dd9475aa9b4b29db60e2c9d10a4d14d4e71 Mon Sep 17 00:00:00 2001
From: hultonha <82228511+hultonha@users.noreply.github.com>
Date: Thu, 19 Aug 2021 09:06:24 +0100
Subject: [PATCH 35/37] Fix issue with mouse input for viewport camera (#3210)

* fix for drift accumulating in the viewport camera

Signed-off-by: hultonha <hultonha@amazon.co.uk>

* fix typo and update how events are stored

Signed-off-by: hultonha <hultonha@amazon.co.uk>

* respond to PR feedback and fix linux and windows build issues

Signed-off-by: hultonha <hultonha@amazon.co.uk>

* fix failing unit tests in camera input

Signed-off-by: hultonha <hultonha@amazon.co.uk>
---
 Code/Editor/CMakeLists.txt                    |   1 +
 Code/Editor/EditorViewportSettings.cpp        |  22 +++
 Code/Editor/EditorViewportSettings.h          |   6 +
 Code/Editor/EditorViewportWidget.cpp          |  37 ++--
 Code/Editor/EditorViewportWidget.h            |   7 +-
 .../test_ModularViewportCameraController.cpp  | 170 ++++++++++++++++++
 Code/Editor/editor_lib_test_files.cmake       |   1 +
 .../AzFramework/Viewport/CameraInput.cpp      |  72 ++++++--
 .../AzFramework/Viewport/CameraInput.h        |  34 +++-
 Code/Framework/AzFramework/CMakeLists.txt     |   3 +
 .../AzFramework/Tests/CameraInputTests.cpp    |   5 +
 .../Tests/Mocks/MockWindowRequests.h          |  41 +++++
 .../Tests/framework_shared_tests_files.cmake  |   1 +
 .../Input/QtEventToAzInputManager.cpp         |  38 ++--
 .../Input/QtEventToAzInputManager.h           |   9 +-
 .../EditorDefaultSelection.cpp                |  23 +--
 .../ModularViewportCameraController.h         |  38 ++++
 .../ModularViewportCameraController.cpp       | 164 ++++++++++-------
 18 files changed, 538 insertions(+), 134 deletions(-)
 create mode 100644 Code/Editor/Lib/Tests/test_ModularViewportCameraController.cpp
 create mode 100644 Code/Framework/AzFramework/Tests/Mocks/MockWindowRequests.h

diff --git a/Code/Editor/CMakeLists.txt b/Code/Editor/CMakeLists.txt
index 9baa83179b..9256fd041f 100644
--- a/Code/Editor/CMakeLists.txt
+++ b/Code/Editor/CMakeLists.txt
@@ -242,6 +242,7 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED)
                 Legacy::CryCommon
                 AZ::AzToolsFramework
                 AZ::AzToolsFramework.Tests
+                AZ::AzFrameworkTestShared
                 AZ::AzToolsFrameworkTestCommon
                 Legacy::EditorLib
                 Gem::AtomToolsFramework.Static
diff --git a/Code/Editor/EditorViewportSettings.cpp b/Code/Editor/EditorViewportSettings.cpp
index 680592a597..6e0ed86d2a 100644
--- a/Code/Editor/EditorViewportSettings.cpp
+++ b/Code/Editor/EditorViewportSettings.cpp
@@ -31,6 +31,8 @@ namespace SandboxEditor
     constexpr AZStd::string_view CameraPanSpeedSetting = "/Amazon/Preferences/Editor/Camera/PanSpeed";
     constexpr AZStd::string_view CameraRotateSmoothnessSetting = "/Amazon/Preferences/Editor/Camera/RotateSmoothness";
     constexpr AZStd::string_view CameraTranslateSmoothnessSetting = "/Amazon/Preferences/Editor/Camera/TranslateSmoothness";
+    constexpr AZStd::string_view CameraTranslateSmoothingSetting = "/Amazon/Preferences/Editor/Camera/TranslateSmoothing";
+    constexpr AZStd::string_view CameraRotateSmoothingSetting = "/Amazon/Preferences/Editor/Camera/RotateSmoothing";
     constexpr AZStd::string_view CameraTranslateForwardIdSetting = "/Amazon/Preferences/Editor/Camera/CameraTranslateForwardId";
     constexpr AZStd::string_view CameraTranslateBackwardIdSetting = "/Amazon/Preferences/Editor/Camera/CameraTranslateBackwardId";
     constexpr AZStd::string_view CameraTranslateLeftIdSetting = "/Amazon/Preferences/Editor/Camera/CameraTranslateLeftId";
@@ -259,6 +261,26 @@ namespace SandboxEditor
         SetRegistry(CameraTranslateSmoothnessSetting, smoothness);
     }
 
+    bool CameraRotateSmoothingEnabled()
+    {
+        return GetRegistry(CameraRotateSmoothingSetting, true);
+    }
+
+    void SetCameraRotateSmoothingEnabled(const bool enabled)
+    {
+        SetRegistry(CameraRotateSmoothingSetting, enabled);
+    }
+
+    bool CameraTranslateSmoothingEnabled()
+    {
+        return GetRegistry(CameraTranslateSmoothingSetting, true);
+    }
+
+    void SetCameraTranslateSmoothingEnabled(const bool enabled)
+    {
+        SetRegistry(CameraTranslateSmoothingSetting, enabled);
+    }
+
     AzFramework::InputChannelId CameraTranslateForwardChannelId()
     {
         return AzFramework::InputChannelId(
diff --git a/Code/Editor/EditorViewportSettings.h b/Code/Editor/EditorViewportSettings.h
index b1488c5528..1aca51395f 100644
--- a/Code/Editor/EditorViewportSettings.h
+++ b/Code/Editor/EditorViewportSettings.h
@@ -80,6 +80,12 @@ namespace SandboxEditor
     SANDBOX_API float CameraTranslateSmoothness();
     SANDBOX_API void SetCameraTranslateSmoothness(float smoothness);
 
+    SANDBOX_API bool CameraRotateSmoothingEnabled();
+    SANDBOX_API void SetCameraRotateSmoothingEnabled(bool enabled);
+
+    SANDBOX_API bool CameraTranslateSmoothingEnabled();
+    SANDBOX_API void SetCameraTranslateSmoothingEnabled(bool enabled);
+
     SANDBOX_API AzFramework::InputChannelId CameraTranslateForwardChannelId();
     SANDBOX_API void SetCameraTranslateForwardChannelId(AZStd::string_view cameraTranslateForwardId);
 
diff --git a/Code/Editor/EditorViewportWidget.cpp b/Code/Editor/EditorViewportWidget.cpp
index 28e8cce33e..4d40c44402 100644
--- a/Code/Editor/EditorViewportWidget.cpp
+++ b/Code/Editor/EditorViewportWidget.cpp
@@ -132,12 +132,11 @@ namespace AZ::ViewportHelpers
 {
     static const char TextCantCreateCameraNoLevel[] = "Cannot create camera when no level is loaded.";
 
-    class EditorEntityNotifications
-        : public AzToolsFramework::EditorEntityContextNotificationBus::Handler
+    class EditorEntityNotifications : public AzToolsFramework::EditorEntityContextNotificationBus::Handler
     {
     public:
-        EditorEntityNotifications(EditorViewportWidget& renderViewport)
-            : m_renderViewport(renderViewport)
+        EditorEntityNotifications(EditorViewportWidget& editorViewportWidget)
+            : m_editorViewportWidget(editorViewportWidget)
         {
             AzToolsFramework::EditorEntityContextNotificationBus::Handler::BusConnect();
         }
@@ -147,22 +146,24 @@ namespace AZ::ViewportHelpers
             AzToolsFramework::EditorEntityContextNotificationBus::Handler::BusDisconnect();
         }
 
-        // AzToolsFramework::EditorEntityContextNotificationBus
+        // AzToolsFramework::EditorEntityContextNotificationBus overrides ...
         void OnStartPlayInEditor() override
         {
-            m_renderViewport.OnStartPlayInEditor();
+            m_editorViewportWidget.OnStartPlayInEditor();
         }
+
         void OnStopPlayInEditor() override
         {
-            m_renderViewport.OnStopPlayInEditor();
+            m_editorViewportWidget.OnStopPlayInEditor();
         }
+
         void OnStartPlayInEditorBegin() override
         {
-            m_renderViewport.OnStartPlayInEditorBegin();
+            m_editorViewportWidget.OnStartPlayInEditorBegin();
         }
 
     private:
-        EditorViewportWidget& m_renderViewport;
+        EditorViewportWidget& m_editorViewportWidget;
     };
 } // namespace AZ::ViewportHelpers
 
@@ -1027,10 +1028,16 @@ bool EditorViewportWidget::ShowingWorldSpace()
 }
 
 AZStd::shared_ptr<AtomToolsFramework::ModularViewportCameraController> CreateModularViewportCameraController(
-    AzFramework::ViewportId viewportId)
+    const AzFramework::ViewportId viewportId)
 {
     auto controller = AZStd::make_shared<AtomToolsFramework::ModularViewportCameraController>();
 
+    controller->SetCameraViewportContextBuilderCallback(
+        [viewportId](AZStd::unique_ptr<AtomToolsFramework::ModularCameraViewportContext>& cameraViewportContext)
+        {
+            cameraViewportContext = AZStd::make_unique<AtomToolsFramework::ModularCameraViewportContextImpl>(viewportId);
+        });
+
     controller->SetCameraPriorityBuilderCallback(
         [](AtomToolsFramework::CameraControllerPriorityFn& cameraControllerPriorityFn)
         {
@@ -1049,6 +1056,16 @@ AZStd::shared_ptr<AtomToolsFramework::ModularViewportCameraController> CreateMod
             {
                 return SandboxEditor::CameraTranslateSmoothness();
             };
+
+            cameraProps.m_rotateSmoothingEnabledFn = []
+            {
+                return SandboxEditor::CameraRotateSmoothingEnabled();
+            };
+
+            cameraProps.m_translateSmoothingEnabledFn = []
+            {
+                return SandboxEditor::CameraTranslateSmoothingEnabled();
+            };
         });
 
     controller->SetCameraListBuilderCallback(
diff --git a/Code/Editor/EditorViewportWidget.h b/Code/Editor/EditorViewportWidget.h
index 33ed001735..a75928b353 100644
--- a/Code/Editor/EditorViewportWidget.h
+++ b/Code/Editor/EditorViewportWidget.h
@@ -54,7 +54,8 @@ namespace AZ::ViewportHelpers
 namespace AtomToolsFramework
 {
     class RenderViewportWidget;
-}
+    class ModularViewportCameraController;
+} // namespace AtomToolsFramework
 
 namespace AzToolsFramework
 {
@@ -389,3 +390,7 @@ private:
 
     AZ_POP_DISABLE_DLL_EXPORT_MEMBER_WARNING
 };
+
+//! Creates a modular camera controller in the configuration used by the editor viewport.
+SANDBOX_API AZStd::shared_ptr<AtomToolsFramework::ModularViewportCameraController> CreateModularViewportCameraController(
+    const AzFramework::ViewportId viewportId);
diff --git a/Code/Editor/Lib/Tests/test_ModularViewportCameraController.cpp b/Code/Editor/Lib/Tests/test_ModularViewportCameraController.cpp
new file mode 100644
index 0000000000..c994458baa
--- /dev/null
+++ b/Code/Editor/Lib/Tests/test_ModularViewportCameraController.cpp
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <AtomToolsFramework/Viewport/ModularViewportCameraController.h>
+#include <AzFramework/Viewport/ViewportControllerList.h>
+#include <AzToolsFramework/Input/QtEventToAzInputManager.h>
+#include <AzToolsFramework/UnitTest/AzToolsFrameworkTestHelpers.h>
+#include <EditorViewportWidget.h>
+#include <Mocks/MockWindowRequests.h>
+
+namespace UnitTest
+{
+    const QSize WidgetSize = QSize(1920, 1080);
+
+    using AzToolsFramework::ViewportInteraction::MouseInteractionEvent;
+
+    class ModularViewportCameraControllerFixture : public AllocatorsTestFixture
+    {
+    public:
+        static const AzFramework::ViewportId TestViewportId;
+
+        void SetUp() override
+        {
+            AllocatorsTestFixture::SetUp();
+
+            m_rootWidget = AZStd::make_unique<QWidget>();
+            m_rootWidget->setFixedSize(WidgetSize);
+
+            m_controllerList = AZStd::make_shared<AzFramework::ViewportControllerList>();
+            m_controllerList->RegisterViewportContext(TestViewportId);
+
+            m_inputChannelMapper = AZStd::make_unique<AzToolsFramework::QtEventToAzInputMapper>(m_rootWidget.get(), TestViewportId);
+        }
+
+        void TearDown()
+        {
+            m_inputChannelMapper.reset();
+
+            m_controllerList->UnregisterViewportContext(TestViewportId);
+            m_controllerList.reset();
+            m_rootWidget.reset();
+
+            AllocatorsTestFixture::TearDown();
+        }
+
+        AZStd::unique_ptr<QWidget> m_rootWidget;
+        AzFramework::ViewportControllerListPtr m_controllerList;
+        AZStd::unique_ptr<AzToolsFramework::QtEventToAzInputMapper> m_inputChannelMapper;
+    };
+
+    const AzFramework::ViewportId ModularViewportCameraControllerFixture::TestViewportId = AzFramework::ViewportId(0);
+
+    class TestModularCameraViewportContextImpl : public AtomToolsFramework::ModularCameraViewportContext
+    {
+    public:
+        AZ::Transform GetCameraTransform() const override
+        {
+            return m_cameraTransform;
+        }
+
+        void SetCameraTransform(const AZ::Transform& transform) override
+        {
+            m_cameraTransform = transform;
+        }
+
+        void ConnectViewMatrixChangedHandler(AZ::RPI::ViewportContext::MatrixChangedEvent::Handler&) override
+        {
+            // noop
+        }
+
+    private:
+        AZ::Transform m_cameraTransform = AZ::Transform::CreateIdentity();
+    };
+
+    TEST_F(ModularViewportCameraControllerFixture, Mouse_movement_does_not_accumulate_excessive_drift_in_modular_viewport_camera)
+    {
+        AzFramework::NativeWindowHandle nativeWindowHandle = nullptr;
+
+        const float deltaTime = 1.0f / 60.0f; // mimic 60fps
+
+        // Given
+        // listen for events signaled from QtEventToAzInputMapper and forward to the controller list
+        QObject::connect(
+            m_inputChannelMapper.get(), &AzToolsFramework::QtEventToAzInputMapper::InputChannelUpdated, m_rootWidget.get(),
+            [this, nativeWindowHandle](const AzFramework::InputChannel* inputChannel, [[maybe_unused]] QEvent* event)
+            {
+                m_controllerList->HandleInputChannelEvent(
+                    AzFramework::ViewportControllerInputEvent{ TestViewportId, nativeWindowHandle, *inputChannel });
+            });
+
+        using ::testing::NiceMock;
+        using ::testing::Return;
+
+        NiceMock<MockWindowRequests> mockWindowRequests;
+        mockWindowRequests.Connect(nativeWindowHandle);
+
+        // note: WindowRequests is used internally by ModularViewportCameraController, this ensures it returns the viewport size we want
+        ON_CALL(mockWindowRequests, GetClientAreaSize())
+            .WillByDefault(Return(AzFramework::WindowSize(WidgetSize.width(), WidgetSize.height())));
+
+        // create editor modular camera
+        auto controller = CreateModularViewportCameraController(TestViewportId);
+
+        // set some overrides for the test
+        AtomToolsFramework::ModularCameraViewportContext* cameraViewportContextView = nullptr;
+        controller->SetCameraViewportContextBuilderCallback(
+            [&cameraViewportContextView](AZStd::unique_ptr<AtomToolsFramework::ModularCameraViewportContext>& cameraViewportContext)
+            {
+                cameraViewportContext = AZStd::make_unique<TestModularCameraViewportContextImpl>();
+                cameraViewportContextView = cameraViewportContext.get();
+            });
+
+        controller->SetCameraPropsBuilderCallback(
+            [](AzFramework::CameraProps& cameraProps)
+            {
+                cameraProps.m_rotateSmoothingEnabledFn = []
+                {
+                    return false;
+                };
+
+                cameraProps.m_translateSmoothingEnabledFn = []
+                {
+                    return false;
+                };
+            });
+
+        m_controllerList->Add(controller);
+
+        // move to the center of the screen
+        auto start = QPoint(WidgetSize.width() / 2, WidgetSize.height() / 2);
+        MouseMove(m_rootWidget.get(), start, QPoint(0, 0));
+        m_controllerList->UpdateViewport({ TestViewportId, AzFramework::FloatSeconds(deltaTime), AZ::ScriptTimePoint() });
+
+        // When
+        // move mouse diagonally to top right, then to bottom left and back repeatedly
+        auto current = start;
+        auto halfDelta = QPoint(200, -200);
+        const int iterationsPerDiagonal = 50;
+        for (int diagonals = 0; diagonals < 80; ++diagonals)
+        {
+            for (int i = 0; i < iterationsPerDiagonal; ++i)
+            {
+                MousePressAndMove(m_rootWidget.get(), current, halfDelta / iterationsPerDiagonal, Qt::MouseButton::RightButton);
+                m_controllerList->UpdateViewport({ TestViewportId, AzFramework::FloatSeconds(deltaTime), AZ::ScriptTimePoint() });
+                current += halfDelta / iterationsPerDiagonal;
+            }
+
+            if (diagonals % 2 == 0)
+            {
+                halfDelta.setX(halfDelta.x() * -1);
+                halfDelta.setY(halfDelta.y() * -1);
+            }
+        }
+
+        QTest::mouseRelease(m_rootWidget.get(), Qt::MouseButton::RightButton, Qt::KeyboardModifier::NoModifier, current);
+        m_controllerList->UpdateViewport({ TestViewportId, AzFramework::FloatSeconds(deltaTime), AZ::ScriptTimePoint() });
+
+        // Then
+        // ensure the camera rotation is the identity (no significant drift has occurred as we moved the mouse)
+        const AZ::Transform cameraRotation = cameraViewportContextView->GetCameraTransform();
+        EXPECT_THAT(cameraRotation.GetRotation(), IsClose(AZ::Quaternion::CreateIdentity()));
+
+        mockWindowRequests.Disconnect();
+    }
+} // namespace UnitTest
diff --git a/Code/Editor/editor_lib_test_files.cmake b/Code/Editor/editor_lib_test_files.cmake
index 49f707b1f6..2ae3d22c19 100644
--- a/Code/Editor/editor_lib_test_files.cmake
+++ b/Code/Editor/editor_lib_test_files.cmake
@@ -21,6 +21,7 @@ set(FILES
     Lib/Tests/test_ViewportTitleDlgPythonBindings.cpp
     Lib/Tests/test_DisplaySettingsPythonBindings.cpp
     Lib/Tests/test_ViewportManipulatorController.cpp
+    Lib/Tests/test_ModularViewportCameraController.cpp
     DisplaySettingsPythonFuncs.cpp
     DisplaySettingsPythonFuncs.h
 )
diff --git a/Code/Framework/AzFramework/AzFramework/Viewport/CameraInput.cpp b/Code/Framework/AzFramework/AzFramework/Viewport/CameraInput.cpp
index c5b6a2ff96..f40c92997a 100644
--- a/Code/Framework/AzFramework/AzFramework/Viewport/CameraInput.cpp
+++ b/Code/Framework/AzFramework/AzFramework/Viewport/CameraInput.cpp
@@ -8,12 +8,12 @@
 
 #include "CameraInput.h"
 
-#include <AzCore/Console/IConsole.h>
 #include <AzCore/Math/MathUtils.h>
 #include <AzCore/Math/Plane.h>
 #include <AzCore/std/numeric.h>
 #include <AzFramework/Input/Devices/Keyboard/InputDeviceKeyboard.h>
 #include <AzFramework/Input/Devices/Mouse/InputDeviceMouse.h>
+#include <AzFramework/Windowing/WindowBus.h>
 
 namespace AzFramework
 {
@@ -26,6 +26,13 @@ namespace AzFramework
         "The default height of the ground plane to do intersection tests against when orbiting");
     AZ_CVAR(float, ed_cameraSystemMinOrbitDistance, 10.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
     AZ_CVAR(float, ed_cameraSystemMaxOrbitDistance, 50.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
+    AZ_CVAR(
+        bool,
+        ed_cameraSystemUseCursor,
+        true,
+        nullptr,
+        AZ::ConsoleFunctorFlags::Null,
+        "Should the camera use cursor absolute positions or motion deltas");
 
     //! return -1.0f if inverted, 1.0f otherwise
     constexpr static float Invert(const bool invert)
@@ -134,9 +141,13 @@ namespace AzFramework
 
     bool CameraSystem::HandleEvents(const InputEvent& event)
     {
-        if (const auto& horizonalMotion = AZStd::get_if<HorizontalMotionEvent>(&event))
+        if (const auto& cursor = AZStd::get_if<CursorEvent>(&event))
         {
-            m_motionDelta.m_x = horizonalMotion->m_delta;
+            m_cursorState.SetCurrentPosition(cursor->m_position);
+        }
+        else if (const auto& horizontalMotion = AZStd::get_if<HorizontalMotionEvent>(&event))
+        {
+            m_motionDelta.m_x = horizontalMotion->m_delta;
         }
         else if (const auto& verticalMotion = AZStd::get_if<VerticalMotionEvent>(&event))
         {
@@ -147,15 +158,18 @@ namespace AzFramework
             m_scrollDelta = scroll->m_delta;
         }
 
-        m_handlingEvents = m_cameras.HandleEvents(event, m_motionDelta, m_scrollDelta);
+        m_handlingEvents =
+            m_cameras.HandleEvents(event, ed_cameraSystemUseCursor ? m_cursorState.CursorDelta() : m_motionDelta, m_scrollDelta);
 
         return m_handlingEvents;
     }
 
     Camera CameraSystem::StepCamera(const Camera& targetCamera, const float deltaTime)
     {
-        const auto nextCamera = m_cameras.StepCamera(targetCamera, m_motionDelta, m_scrollDelta, deltaTime);
+        const auto nextCamera = m_cameras.StepCamera(
+            targetCamera, ed_cameraSystemUseCursor ? m_cursorState.CursorDelta() : m_motionDelta, m_scrollDelta, deltaTime);
 
+        m_cursorState.Update();
         m_motionDelta = ScreenVector{ 0, 0 };
         m_scrollDelta = 0.0f;
 
@@ -727,18 +741,36 @@ namespace AzFramework
         Camera camera;
         // note: the math for the lerp smoothing implementation for camera rotation and translation was inspired by this excellent
         // article by Scott Lembcke: https://www.gamasutra.com/blogs/ScottLembcke/20180404/316046/Improved_Lerp_Smoothing.php
-        const float lookRate = AZStd::exp2(cameraProps.m_rotateSmoothnessFn());
-        const float lookT = AZStd::exp2(-lookRate * deltaTime);
-        camera.m_pitch = AZ::Lerp(targetCamera.m_pitch, currentCamera.m_pitch, lookT);
-        camera.m_yaw = AZ::Lerp(targetYaw, currentYaw, lookT);
-        const float moveRate = AZStd::exp2(cameraProps.m_translateSmoothnessFn());
-        const float moveT = AZStd::exp2(-moveRate * deltaTime);
-        camera.m_lookDist = AZ::Lerp(targetCamera.m_lookDist, currentCamera.m_lookDist, moveT);
-        camera.m_lookAt = targetCamera.m_lookAt.Lerp(currentCamera.m_lookAt, moveT);
+        if (cameraProps.m_rotateSmoothingEnabledFn())
+        {
+            const float lookRate = AZStd::exp2(cameraProps.m_rotateSmoothnessFn());
+            const float lookTime = AZStd::exp2(-lookRate * deltaTime);
+            camera.m_pitch = AZ::Lerp(targetCamera.m_pitch, currentCamera.m_pitch, lookTime);
+            camera.m_yaw = AZ::Lerp(targetYaw, currentYaw, lookTime);
+        }
+        else
+        {
+            camera.m_pitch = targetCamera.m_pitch;
+            camera.m_yaw = targetYaw;
+        }
+
+        if (cameraProps.m_translateSmoothingEnabledFn())
+        {
+            const float moveRate = AZStd::exp2(cameraProps.m_translateSmoothnessFn());
+            const float moveTime = AZStd::exp2(-moveRate * deltaTime);
+            camera.m_lookDist = AZ::Lerp(targetCamera.m_lookDist, currentCamera.m_lookDist, moveTime);
+            camera.m_lookAt = targetCamera.m_lookAt.Lerp(currentCamera.m_lookAt, moveTime);
+        }
+        else
+        {
+            camera.m_lookDist = targetCamera.m_lookDist;
+            camera.m_lookAt = targetCamera.m_lookAt;
+        }
+
         return camera;
     }
 
-    InputEvent BuildInputEvent(const InputChannel& inputChannel)
+    InputEvent BuildInputEvent(const InputChannel& inputChannel, const WindowSize& windowSize)
     {
         const auto& inputChannelId = inputChannel.GetInputChannelId();
         const auto& inputDeviceId = inputChannel.GetInputDevice().GetInputDeviceId();
@@ -753,7 +785,16 @@ namespace AzFramework
         // accept active mouse channel updates, inactive movement channels will just have a 0 delta
         if (inputChannel.IsActive())
         {
-            if (inputChannelId == InputDeviceMouse::Movement::X)
+            if (inputChannelId == InputDeviceMouse::SystemCursorPosition)
+            {
+                const auto* position = inputChannel.GetCustomData<AzFramework::InputChannel::PositionData2D>();
+                AZ_Assert(position, "Expected PositionData2D but found nullptr");
+
+                return CursorEvent{ ScreenPoint(
+                    position->m_normalizedPosition.GetX() * windowSize.m_width,
+                    position->m_normalizedPosition.GetY() * windowSize.m_height) };
+            }
+            else if (inputChannelId == InputDeviceMouse::Movement::X)
             {
                 return HorizontalMotionEvent{ aznumeric_cast<int>(inputChannel.GetValue()) };
             }
@@ -761,6 +802,7 @@ namespace AzFramework
             {
                 return VerticalMotionEvent{ aznumeric_cast<int>(inputChannel.GetValue()) };
             }
+
             else if (inputChannelId == InputDeviceMouse::Movement::Z)
             {
                 return ScrollEvent{ inputChannel.GetValue() };
diff --git a/Code/Framework/AzFramework/AzFramework/Viewport/CameraInput.h b/Code/Framework/AzFramework/AzFramework/Viewport/CameraInput.h
index bb0df4853a..0b7bbbc30d 100644
--- a/Code/Framework/AzFramework/AzFramework/Viewport/CameraInput.h
+++ b/Code/Framework/AzFramework/AzFramework/Viewport/CameraInput.h
@@ -8,17 +8,23 @@
 
 #pragma once
 
+#include <AzCore/Console/IConsole.h>
 #include <AzCore/Math/Matrix3x3.h>
 #include <AzCore/Math/Transform.h>
 #include <AzCore/std/containers/variant.h>
 #include <AzCore/std/optional.h>
 #include <AzFramework/Input/Channels/InputChannel.h>
 #include <AzFramework/Viewport/ClickDetector.h>
+#include <AzFramework/Viewport/CursorState.h>
 #include <AzFramework/Viewport/ScreenGeometry.h>
 #include <AzFramework/Viewport/ViewportId.h>
 
 namespace AzFramework
 {
+    AZ_CVAR_EXTERNED(bool, ed_cameraSystemUseCursor);
+
+    struct WindowSize;
+
     //! Returns Euler angles (pitch, roll, yaw) for the incoming orientation.
     //! @note Order of rotation is Z, Y, X.
     AZ::Vector3 EulerAngles(const AZ::Matrix3x3& orientation);
@@ -79,6 +85,11 @@ namespace AzFramework
     using HorizontalMotionEvent = MotionEvent<struct HorizontalMotionTag>;
     using VerticalMotionEvent = MotionEvent<struct VerticalMotionTag>;
 
+    struct CursorEvent
+    {
+        ScreenPoint m_position;
+    };
+
     struct ScrollEvent
     {
         float m_delta;
@@ -93,7 +104,8 @@ namespace AzFramework
     };
 
     //! Represents a type-safe union of input events that are handled by the camera system.
-    using InputEvent = AZStd::variant<AZStd::monostate, HorizontalMotionEvent, VerticalMotionEvent, ScrollEvent, DiscreteInputEvent>;
+    using InputEvent =
+        AZStd::variant<AZStd::monostate, HorizontalMotionEvent, VerticalMotionEvent, CursorEvent, ScrollEvent, DiscreteInputEvent>;
 
     //! Base class for all camera behaviors.
     //! The core interface consists of:
@@ -219,10 +231,14 @@ namespace AzFramework
     //! Properties to use to configure behavior across all types of camera.
     struct CameraProps
     {
-        AZStd::function<float()>
-            m_rotateSmoothnessFn; //!< Rotate smoothing value (useful approx range 3-6, higher values give sharper feel).
-        AZStd::function<float()>
-            m_translateSmoothnessFn; //!< Translate smoothing value (useful approx range 3-6, higher values give sharper feel).
+        //! Rotate smoothing value (useful approx range 3-6, higher values give sharper feel).
+        AZStd::function<float()> m_rotateSmoothnessFn;
+        //! Translate smoothing value (useful approx range 3-6, higher values give sharper feel).
+        AZStd::function<float()> m_translateSmoothnessFn;
+        //! Enable/disable rotation smoothing.
+        AZStd::function<bool()> m_rotateSmoothingEnabledFn;
+        //! Enable/disable translation smoothing.
+        AZStd::function<bool()> m_translateSmoothingEnabledFn;
     };
 
     //! An interpolation function to smoothly interpolate all camera properties from currentCamera to targetCamera.
@@ -262,12 +278,16 @@ namespace AzFramework
     public:
         bool HandleEvents(const InputEvent& event);
         Camera StepCamera(const Camera& targetCamera, float deltaTime);
-        bool HandlingEvents() const { return m_handlingEvents; }
+        bool HandlingEvents() const
+        {
+            return m_handlingEvents;
+        }
 
         Cameras m_cameras; //!< Represents a collection of camera inputs that together provide a camera controller.
 
     private:
         ScreenVector m_motionDelta; //!< The delta used for look/orbit/pan (rotation + translation) - two dimensional.
+        CursorState m_cursorState; //!< The current and previous position of the cursor (used to calculate movement delta).
         float m_scrollDelta = 0.0f; //!< The delta used for dolly/movement (translation) - one dimensional.
         bool m_handlingEvents = false; //!< Is the camera system currently handling events (events are consumed and not propagated).
     };
@@ -548,5 +568,5 @@ namespace AzFramework
     }
 
     //! Map from a generic InputChannel event to a camera specific InputEvent.
-    InputEvent BuildInputEvent(const InputChannel& inputChannel);
+    InputEvent BuildInputEvent(const InputChannel& inputChannel, const WindowSize& windowSize);
 } // namespace AzFramework
diff --git a/Code/Framework/AzFramework/CMakeLists.txt b/Code/Framework/AzFramework/CMakeLists.txt
index 8a68aac887..4359ae1f02 100644
--- a/Code/Framework/AzFramework/CMakeLists.txt
+++ b/Code/Framework/AzFramework/CMakeLists.txt
@@ -70,6 +70,9 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED)
             PRIVATE
                 AZ::AzCore
                 AZ::AzFramework
+            PUBLIC
+                AZ::AzTest
+                AZ::AzTestShared
     )
 
     if(PAL_TRAIT_BUILD_HOST_TOOLS)
diff --git a/Code/Framework/AzFramework/Tests/CameraInputTests.cpp b/Code/Framework/AzFramework/Tests/CameraInputTests.cpp
index 590d46850e..ef340a41a5 100644
--- a/Code/Framework/AzFramework/Tests/CameraInputTests.cpp
+++ b/Code/Framework/AzFramework/Tests/CameraInputTests.cpp
@@ -59,10 +59,15 @@ namespace UnitTest
             m_cameraSystem->m_cameras.AddCamera(m_firstPersonRotateCamera);
             m_cameraSystem->m_cameras.AddCamera(m_firstPersonTranslateCamera);
             m_cameraSystem->m_cameras.AddCamera(orbitCamera);
+
+            // these tests rely on using motion delta, not cursor positions (default is true)
+            AzFramework::ed_cameraSystemUseCursor = false;
         }
 
         void TearDown() override
         {
+            AzFramework::ed_cameraSystemUseCursor = true;
+
             m_firstPersonRotateCamera.reset();
             m_firstPersonTranslateCamera.reset();
 
diff --git a/Code/Framework/AzFramework/Tests/Mocks/MockWindowRequests.h b/Code/Framework/AzFramework/Tests/Mocks/MockWindowRequests.h
new file mode 100644
index 0000000000..63f73d0b28
--- /dev/null
+++ b/Code/Framework/AzFramework/Tests/Mocks/MockWindowRequests.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzFramework/Windowing/WindowBus.h>
+
+#include <gmock/gmock.h>
+
+namespace UnitTest
+{
+    class MockWindowRequests : public AzFramework::WindowRequestBus::Handler
+    {
+    public:
+        void Connect(AzFramework::NativeWindowHandle handle)
+        {
+            AzFramework::WindowRequestBus::Handler::BusConnect(handle);
+        }
+        void Disconnect()
+        {
+            AzFramework::WindowRequestBus::Handler::BusDisconnect();
+        }
+
+        // AzFramework::WindowRequestBus overrides ...
+        MOCK_METHOD1(SetWindowTitle, void(const AZStd::string&));
+        MOCK_CONST_METHOD0(GetClientAreaSize, AzFramework::WindowSize());
+        MOCK_METHOD1(ResizeClientArea, void(AzFramework::WindowSize clientAreaSize));
+        MOCK_CONST_METHOD0(GetFullScreenState, bool());
+        MOCK_METHOD1(SetFullScreenState, void(bool));
+        MOCK_CONST_METHOD0(CanToggleFullScreenState, bool());
+        MOCK_METHOD0(ToggleFullScreenState, void());
+        MOCK_CONST_METHOD0(GetDpiScaleFactor, float());
+        MOCK_CONST_METHOD0(GetSyncInterval, uint32_t());
+        MOCK_CONST_METHOD0(GetDisplayRefreshRate, uint32_t());
+    };
+} // namespace UnitTest
diff --git a/Code/Framework/AzFramework/Tests/framework_shared_tests_files.cmake b/Code/Framework/AzFramework/Tests/framework_shared_tests_files.cmake
index 3d2c2a51be..85c00a2e8a 100644
--- a/Code/Framework/AzFramework/Tests/framework_shared_tests_files.cmake
+++ b/Code/Framework/AzFramework/Tests/framework_shared_tests_files.cmake
@@ -8,6 +8,7 @@
 
 set(FILES
     Mocks/MockSpawnableEntitiesInterface.h
+    Mocks/MockWindowRequests.h
     Utils/Utils.h
     Utils/Utils.cpp
     FrameworkApplicationFixture.h
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Input/QtEventToAzInputManager.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/Input/QtEventToAzInputManager.cpp
index b7776238ba..260270e85e 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Input/QtEventToAzInputManager.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Input/QtEventToAzInputManager.cpp
@@ -285,7 +285,7 @@ namespace AzToolsFramework
         }
     }
 
-    void QtEventToAzInputMapper::ProcessPendingMouseEvents()
+    void QtEventToAzInputMapper::ProcessPendingMouseEvents(const QPoint& cursorDelta)
     {
         auto systemCursorChannel =
             GetInputChannel<AzFramework::InputChannelDeltaWithSharedPosition2D>(AzFramework::InputDeviceMouse::SystemCursorPosition);
@@ -297,14 +297,8 @@ namespace AzToolsFramework
             GetInputChannel<AzFramework::InputChannelDeltaWithSharedPosition2D>(AzFramework::InputDeviceMouse::Movement::Z);
 
         systemCursorChannel->ProcessRawInputEvent(m_mouseDevice->m_cursorPositionData2D->m_normalizedPositionDelta.GetLength());
-        // Generate movement events based on the pixel delta divided by the DPI scaling factor, to calculate a rough approximation
-        // of cursor movement velocity.
-        movementXChannel->ProcessRawInputEvent(
-            m_mouseDevice->m_cursorPositionData2D->m_normalizedPositionDelta.GetX() * aznumeric_cast<float>(m_sourceWidget->width()) /
-            m_sourceWidget->devicePixelRatioF());
-        movementYChannel->ProcessRawInputEvent(
-            m_mouseDevice->m_cursorPositionData2D->m_normalizedPositionDelta.GetY() * aznumeric_cast<float>(m_sourceWidget->height()) /
-            m_sourceWidget->devicePixelRatioF());
+        movementXChannel->ProcessRawInputEvent(cursorDelta.x());
+        movementYChannel->ProcessRawInputEvent(cursorDelta.y());
         mouseWheelChannel->ProcessRawInputEvent(0.0f);
 
         NotifyUpdateChannelIfNotIdle(systemCursorChannel, nullptr);
@@ -337,41 +331,43 @@ namespace AzToolsFramework
         }
     }
 
-    AZ::Vector2 QtEventToAzInputMapper::WidgetPositionToNormalizedPosition(QPoint position)
+    AZ::Vector2 QtEventToAzInputMapper::WidgetPositionToNormalizedPosition(const QPoint& position)
     {
         const float normalizedX = aznumeric_cast<float>(position.x()) / aznumeric_cast<float>(m_sourceWidget->width());
         const float normalizedY = aznumeric_cast<float>(position.y()) / aznumeric_cast<float>(m_sourceWidget->height());
-        return AZ::Vector2{normalizedX, normalizedY};
+        return AZ::Vector2{ normalizedX, normalizedY };
     }
 
-    QPoint QtEventToAzInputMapper::NormalizedPositionToWidgetPosition(AZ::Vector2 normalizedPosition)
+    QPoint QtEventToAzInputMapper::NormalizedPositionToWidgetPosition(const AZ::Vector2& normalizedPosition)
     {
         const int denormalizedX = aznumeric_cast<int>(normalizedPosition.GetX() * m_sourceWidget->width());
         const int denormalizedY = aznumeric_cast<int>(normalizedPosition.GetY() * m_sourceWidget->height());
-        return QPoint{denormalizedX, denormalizedY};
+        return QPoint{ denormalizedX, denormalizedY };
     }
 
     void QtEventToAzInputMapper::HandleMouseMoveEvent(QMouseEvent* mouseEvent)
     {
-        AZ::Vector2 lastCursorPosition = m_mouseDevice->m_cursorPositionData2D->m_normalizedPosition;
+        const QPoint cursorPosition = mouseEvent->pos();
+        const QPoint cursorDelta = cursorPosition - m_previousCursorPosition;
 
-        const QPoint mousePos = mouseEvent->pos();
-        const AZ::Vector2 normalizedPosition = WidgetPositionToNormalizedPosition(mousePos);
-        m_mouseDevice->m_cursorPositionData2D->m_normalizedPositionDelta = normalizedPosition - m_mouseDevice->m_cursorPositionData2D->m_normalizedPosition;
-        m_mouseDevice->m_cursorPositionData2D->m_normalizedPosition = normalizedPosition;
-        ProcessPendingMouseEvents();
+        m_mouseDevice->m_cursorPositionData2D->m_normalizedPosition = WidgetPositionToNormalizedPosition(cursorPosition);
+        m_mouseDevice->m_cursorPositionData2D->m_normalizedPositionDelta = WidgetPositionToNormalizedPosition(cursorDelta);
+
+        ProcessPendingMouseEvents(cursorDelta);
 
         if (m_capturingCursor)
         {
             // Reset our cursor position to the previous point.
-            QPoint targetScreenPosition = m_sourceWidget->mapToGlobal(NormalizedPositionToWidgetPosition(lastCursorPosition));
+            const QPoint targetScreenPosition = m_sourceWidget->mapToGlobal(m_previousCursorPosition);
             AzQtComponents::SetCursorPos(targetScreenPosition);
 
             // Even though we just set the cursor position, there are edge cases such as remote desktop that will leave
             // the cursor position unchanged. For safety, we re-cache our last cursor position for delta generation.
-            QPoint actualWidgetPosition = m_sourceWidget->mapFromGlobal(QCursor::pos());
+            const QPoint actualWidgetPosition = m_sourceWidget->mapFromGlobal(QCursor::pos());
             m_mouseDevice->m_cursorPositionData2D->m_normalizedPosition = WidgetPositionToNormalizedPosition(actualWidgetPosition);
         }
+
+        m_previousCursorPosition = cursorPosition;
     }
 
     void QtEventToAzInputMapper::HandleKeyEvent(QKeyEvent* keyEvent)
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Input/QtEventToAzInputManager.h b/Code/Framework/AzToolsFramework/AzToolsFramework/Input/QtEventToAzInputManager.h
index 0187cb2e5b..6e73bf4f9c 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Input/QtEventToAzInputManager.h
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Input/QtEventToAzInputManager.h
@@ -21,6 +21,7 @@
 
 #include <QEvent>
 #include <QObject>
+#include <QPoint>
 #endif //! defined(Q_MOC_RUN)
 
 class QWidget;
@@ -111,12 +112,12 @@ namespace AzToolsFramework
         void NotifyUpdateChannelIfNotIdle(const AzFramework::InputChannel* channel, QEvent* event);
 
         // Processes any pending mouse movement events, this allows mouse movement channels to close themselves.
-        void ProcessPendingMouseEvents();
+        void ProcessPendingMouseEvents(const QPoint& cursorDelta);
 
         // Converts a point in logical source widget space [0..m_sourceWidget->size()] to normalized [0..1] space.
-        AZ::Vector2 WidgetPositionToNormalizedPosition(QPoint position);
+        AZ::Vector2 WidgetPositionToNormalizedPosition(const QPoint& position);
         // Converts a point in normalized [0..1] space to logical source widget space [0..m_sourceWidget->size()].
-        QPoint NormalizedPositionToWidgetPosition(AZ::Vector2 normalizedPosition);
+        QPoint NormalizedPositionToWidgetPosition(const AZ::Vector2& normalizedPosition);
 
         // Handle mouse click events.
         void HandleMouseButtonEvent(QMouseEvent* mouseEvent);
@@ -148,6 +149,8 @@ namespace AzToolsFramework
         AZStd::unordered_set<Qt::Key> m_highPriorityKeys;
         // A lookup table for AZ input channel ID -> physical input channel on our mouse or keyboard device.
         AZStd::unordered_map<AzFramework::InputChannelId, AzFramework::InputChannel*> m_channels;
+        // Where the position of the mouse cursor was at the last cursor event.
+        QPoint m_previousCursorPosition;
         // The source widget to map events from, used to calculate the relative mouse position within the widget bounds.
         QWidget* m_sourceWidget;
         // Flags whether or not Qt events should currently be processed.
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.cpp b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.cpp
index 0eae7707bc..d7dd008c9e 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.cpp
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.cpp
@@ -188,7 +188,7 @@ namespace AzToolsFramework
             return false;
         }
 
-        using namespace AzToolsFramework::ViewportInteraction;
+        using AzToolsFramework::ViewportInteraction::MouseEvent;
         const auto& mouseInteraction = mouseInteractionEvent.m_mouseInteraction;
         // store the current interaction for use in DrawManipulators
         m_currentInteraction = mouseInteraction;
@@ -196,28 +196,19 @@ namespace AzToolsFramework
         switch (mouseInteractionEvent.m_mouseEvent)
         {
         case MouseEvent::Down:
-            {
-                return m_manipulatorManager->ConsumeViewportMousePress(mouseInteraction);
-            }
+            return m_manipulatorManager->ConsumeViewportMousePress(mouseInteraction);
         case MouseEvent::DoubleClick:
-            {
-                return false;
-            }
+            return false;
         case MouseEvent::Move:
             {
-                AzToolsFramework::ManipulatorManager::ConsumeMouseMoveResult mouseMoveResult =
-                    AzToolsFramework::ManipulatorManager::ConsumeMouseMoveResult::None;
-                mouseMoveResult = m_manipulatorManager->ConsumeViewportMouseMove(mouseInteraction);
+                const AzToolsFramework::ManipulatorManager::ConsumeMouseMoveResult mouseMoveResult =
+                    m_manipulatorManager->ConsumeViewportMouseMove(mouseInteraction);
                 return mouseMoveResult == AzToolsFramework::ManipulatorManager::ConsumeMouseMoveResult::Interacting;
             }
         case MouseEvent::Up:
-            {
-                return m_manipulatorManager->ConsumeViewportMouseRelease(mouseInteraction);
-            }
+            return m_manipulatorManager->ConsumeViewportMouseRelease(mouseInteraction);
         case MouseEvent::Wheel:
-            {
-                return m_manipulatorManager->ConsumeViewportMouseWheel(mouseInteraction);
-            }
+            return m_manipulatorManager->ConsumeViewportMouseWheel(mouseInteraction);
         default:
             return false;
         }
diff --git a/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Viewport/ModularViewportCameraController.h b/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Viewport/ModularViewportCameraController.h
index e6a666c640..42fe9a01c9 100644
--- a/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Viewport/ModularViewportCameraController.h
+++ b/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Viewport/ModularViewportCameraController.h
@@ -18,9 +18,22 @@ namespace AtomToolsFramework
 {
     class ModularViewportCameraControllerInstance;
 
+    //! A reduced ViewportContext interface for use by the ModularViewportCameraController.
+    //! @note This extra indirection is used to facilitate testing the ModularViewportCameraController.
+    class ModularCameraViewportContext
+    {
+    public:
+        virtual ~ModularCameraViewportContext() = default;
+
+        virtual AZ::Transform GetCameraTransform() const = 0;
+        virtual void SetCameraTransform(const AZ::Transform& transform) = 0;
+        virtual void ConnectViewMatrixChangedHandler(AZ::RPI::ViewportContext::MatrixChangedEvent::Handler& handler) = 0;
+    };
+
     //! A function object to represent returning a camera controller priority.
     using CameraControllerPriorityFn =
         AZStd::function<AzFramework::ViewportControllerPriority(const AzFramework::CameraSystem& cameraSystem)>;
+    using CameraViewportContextFn = AZStd::function<AZStd::unique_ptr<ModularCameraViewportContext>(AzFramework::ViewportId)>;
 
     //! The default behavior for what priority the camera controller should respond to events at.
     //! @note This can change based on the state of the camera controller/system.
@@ -38,6 +51,7 @@ namespace AtomToolsFramework
         using CameraListBuilder = AZStd::function<void(AzFramework::Cameras&)>;
         using CameraPropsBuilder = AZStd::function<void(AzFramework::CameraProps&)>;
         using CameraPriorityBuilder = AZStd::function<void(CameraControllerPriorityFn&)>;
+        using CameraViewportContextBuilder = AZStd::function<void(AZStd::unique_ptr<ModularCameraViewportContext>&)>;
 
         //! Sets the camera list builder callback used to populate new ModularViewportCameraControllerInstances.
         void SetCameraListBuilderCallback(const CameraListBuilder& builder);
@@ -45,6 +59,8 @@ namespace AtomToolsFramework
         void SetCameraPropsBuilderCallback(const CameraPropsBuilder& builder);
         //! Sets the camera controller priority builder callback used to populate new ModularViewportCameraControllerInstances.
         void SetCameraPriorityBuilderCallback(const CameraPriorityBuilder& builder);
+        //! Sets the camera controller viewport context builder callback to populate new ModularViewportCameraControllerInstances.
+        void SetCameraViewportContextBuilderCallback(const CameraViewportContextBuilder& builder);
 
     private:
         //! Sets up a camera list based on this controller's CameraListBuilderCallback.
@@ -53,6 +69,8 @@ namespace AtomToolsFramework
         void SetupCameraProperties(AzFramework::CameraProps& cameraProps);
         //! Sets up how the camera controller should decide at what priority level to respond to.
         void SetupCameraControllerPriority(CameraControllerPriorityFn& cameraPriorityFn);
+        //! Sets up what viewport context should be used by the camera controller.
+        void SetupCameraControllerViewportContext(AZStd::unique_ptr<ModularCameraViewportContext>& cameraViewportContext);
 
         //! Builder to generate a list of CameraInputs to run in the ModularViewportCameraControllerInstance.
         CameraListBuilder m_cameraListBuilder;
@@ -60,6 +78,24 @@ namespace AtomToolsFramework
         CameraPropsBuilder m_cameraPropsBuilder;
         //! Builder to define what priority level the camera controller should respond to events at.
         CameraPriorityBuilder m_cameraControllerPriorityBuilder;
+        //! Builder to define what viewport context interface the camera controller should use.
+        CameraViewportContextBuilder m_cameraViewportContextBuilder;
+    };
+
+    //! The production modular camera viewport context backed by an AZ::RPI::ViewportContextPtr.
+    //! @note This is instantiated during normal runtime use.
+    class ModularCameraViewportContextImpl : public ModularCameraViewportContext
+    {
+    public:
+        explicit ModularCameraViewportContextImpl(AzFramework::ViewportId viewportId);
+
+        // ModularCameraViewportContext overrides ...
+        AZ::Transform GetCameraTransform() const override;
+        void SetCameraTransform(const AZ::Transform& transform) override;
+        void ConnectViewMatrixChangedHandler(AZ::RPI::ViewportContext::MatrixChangedEvent::Handler& handler) override;
+
+    private:
+        AzFramework::ViewportId m_viewportId;
     };
 
     //! A customizable camera controller that can be configured to run a varying set of CameraInput instances.
@@ -115,5 +151,7 @@ namespace AtomToolsFramework
         bool m_updatingTransformInternally = false;
         //! Listen for camera view changes outside of the camera controller.
         AZ::RPI::ViewportContext::MatrixChangedEvent::Handler m_cameraViewMatrixChangeHandler;
+        //! The current instance of the modular camera viewport context.
+        AZStd::unique_ptr<ModularCameraViewportContext> m_modularCameraViewportContext;
     };
 } // namespace AtomToolsFramework
diff --git a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Viewport/ModularViewportCameraController.cpp b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Viewport/ModularViewportCameraController.cpp
index e98df83930..0fc55e2363 100644
--- a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Viewport/ModularViewportCameraController.cpp
+++ b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Viewport/ModularViewportCameraController.cpp
@@ -41,6 +41,7 @@ namespace AtomToolsFramework
         display.DrawLine(transform.GetTranslation(), transform.GetTranslation() + transform.GetBasisZ().GetNormalizedSafe() * axisLength);
     }
 
+    // convenience function to access the ViewportContext for the given ViewportId.
     static AZ::RPI::ViewportContextPtr RetrieveViewportContext(const AzFramework::ViewportId viewportId)
     {
         auto viewportContextManager = AZ::Interface<AZ::RPI::ViewportContextRequestsInterface>::Get();
@@ -58,6 +59,35 @@ namespace AtomToolsFramework
         return viewportContext;
     }
 
+    ModularCameraViewportContextImpl::ModularCameraViewportContextImpl(const AzFramework::ViewportId viewportId)
+        : m_viewportId(viewportId)
+    {
+    }
+
+    AZ::Transform ModularCameraViewportContextImpl::GetCameraTransform() const
+    {
+        if (auto viewportContext = RetrieveViewportContext(m_viewportId))
+        {
+            return viewportContext->GetCameraTransform();
+        }
+
+        return AZ::Transform::CreateIdentity();
+    }
+    void ModularCameraViewportContextImpl::SetCameraTransform(const AZ::Transform& transform)
+    {
+        if (auto viewportContext = RetrieveViewportContext(m_viewportId))
+        {
+            viewportContext->SetCameraTransform(transform);
+        }
+    }
+    void ModularCameraViewportContextImpl::ConnectViewMatrixChangedHandler(AZ::RPI::ViewportContext::MatrixChangedEvent::Handler& handler)
+    {
+        if (auto viewportContext = RetrieveViewportContext(m_viewportId))
+        {
+            viewportContext->ConnectViewMatrixChangedHandler(handler);
+        }
+    }
+
     void ModularViewportCameraController::SetCameraListBuilderCallback(const CameraListBuilder& builder)
     {
         m_cameraListBuilder = builder;
@@ -73,6 +103,11 @@ namespace AtomToolsFramework
         m_cameraControllerPriorityBuilder = builder;
     }
 
+    void ModularViewportCameraController::SetCameraViewportContextBuilderCallback(const CameraViewportContextBuilder& builder)
+    {
+        m_cameraViewportContextBuilder = builder;
+    }
+
     void ModularViewportCameraController::SetupCameras(AzFramework::Cameras& cameras)
     {
         if (m_cameraListBuilder)
@@ -97,6 +132,15 @@ namespace AtomToolsFramework
         }
     }
 
+    void ModularViewportCameraController::SetupCameraControllerViewportContext(
+        AZStd::unique_ptr<ModularCameraViewportContext>& cameraViewportContext)
+    {
+        if (m_cameraViewportContextBuilder)
+        {
+            m_cameraViewportContextBuilder(cameraViewportContext);
+        }
+    }
+
     // what priority should the camera system respond to
     AzFramework::ViewportControllerPriority DefaultCameraControllerPriority(const AzFramework::CameraSystem& cameraSystem)
     {
@@ -119,23 +163,20 @@ namespace AtomToolsFramework
         controller->SetupCameras(m_cameraSystem.m_cameras);
         controller->SetupCameraProperties(m_cameraProps);
         controller->SetupCameraControllerPriority(m_priorityFn);
+        controller->SetupCameraControllerViewportContext(m_modularCameraViewportContext);
 
-        if (auto viewportContext = RetrieveViewportContext(GetViewportId()))
+        auto handleCameraChange = [this](const AZ::Matrix4x4&)
         {
-            auto handleCameraChange = [this, viewportContext](const AZ::Matrix4x4&)
+            // ignore these updates if the camera is being updated internally
+            if (!m_updatingTransformInternally)
             {
-                // ignore these updates if the camera is being updated internally
-                if (!m_updatingTransformInternally)
-                {
-                    UpdateCameraFromTransform(m_targetCamera, viewportContext->GetCameraTransform());
-                    m_camera = m_targetCamera;
-                }
-            };
+                UpdateCameraFromTransform(m_targetCamera, m_modularCameraViewportContext->GetCameraTransform());
+                m_camera = m_targetCamera;
+            }
+        };
 
-            m_cameraViewMatrixChangeHandler = AZ::RPI::ViewportContext::MatrixChangedEvent::Handler(handleCameraChange);
-
-            viewportContext->ConnectViewMatrixChangedHandler(m_cameraViewMatrixChangeHandler);
-        }
+        m_cameraViewMatrixChangeHandler = AZ::RPI::ViewportContext::MatrixChangedEvent::Handler(handleCameraChange);
+        m_modularCameraViewportContext->ConnectViewMatrixChangedHandler(m_cameraViewMatrixChangeHandler);
 
         AzFramework::ViewportDebugDisplayEventBus::Handler::BusConnect(AzToolsFramework::GetEntityContextId());
         ModularViewportCameraControllerRequestBus::Handler::BusConnect(viewportId);
@@ -151,7 +192,11 @@ namespace AtomToolsFramework
     {
         if (event.m_priority == m_priorityFn(m_cameraSystem))
         {
-            return m_cameraSystem.HandleEvents(AzFramework::BuildInputEvent(event.m_inputChannel));
+            AzFramework::WindowSize windowSize;
+            AzFramework::WindowRequestBus::EventResult(
+                windowSize, event.m_windowHandle, &AzFramework::WindowRequestBus::Events::GetClientAreaSize);
+
+            return m_cameraSystem.HandleEvents(AzFramework::BuildInputEvent(event.m_inputChannel, windowSize));
         }
 
         return false;
@@ -165,61 +210,58 @@ namespace AtomToolsFramework
             return;
         }
 
-        if (auto viewportContext = RetrieveViewportContext(GetViewportId()))
+        m_updatingTransformInternally = true;
+
+        if (m_cameraMode == CameraMode::Control)
         {
-            m_updatingTransformInternally = true;
+            m_targetCamera = m_cameraSystem.StepCamera(m_targetCamera, event.m_deltaTime.count());
+            m_camera = AzFramework::SmoothCamera(m_camera, m_targetCamera, m_cameraProps, event.m_deltaTime.count());
 
-            if (m_cameraMode == CameraMode::Control)
+            // if there has been an interpolation, only clear the look at point if it is no longer
+            // centered in the view (the camera has looked away from it)
+            if (m_lookAtAfterInterpolation.has_value())
             {
-                m_targetCamera = m_cameraSystem.StepCamera(m_targetCamera, event.m_deltaTime.count());
-                m_camera = AzFramework::SmoothCamera(m_camera, m_targetCamera, m_cameraProps, event.m_deltaTime.count());
-
-                // if there has been an interpolation, only clear the look at point if it is no longer
-                // centered in the view (the camera has looked away from it)
-                if (m_lookAtAfterInterpolation.has_value())
+                if (const float lookDirection =
+                        (*m_lookAtAfterInterpolation - m_camera.Translation()).GetNormalized().Dot(m_camera.Transform().GetBasisY());
+                    !AZ::IsCloseMag(lookDirection, 1.0f, 0.001f))
                 {
-                    if (const float lookDirection =
-                            (*m_lookAtAfterInterpolation - m_camera.Translation()).GetNormalized().Dot(m_camera.Transform().GetBasisY());
-                        !AZ::IsCloseMag(lookDirection, 1.0f, 0.001f))
-                    {
-                        m_lookAtAfterInterpolation = {};
-                    }
+                    m_lookAtAfterInterpolation = {};
                 }
-
-                viewportContext->SetCameraTransform(m_camera.Transform());
-            }
-            else if (m_cameraMode == CameraMode::Animation)
-            {
-                const auto smootherStepFn = [](const float t)
-                {
-                    return t * t * t * (t * (t * 6.0f - 15.0f) + 10.0f);
-                };
-
-                const auto& [transformStart, transformEnd, animationTime] = m_cameraAnimation;
-
-                const float transitionTime = smootherStepFn(animationTime);
-                const AZ::Transform current = AZ::Transform::CreateFromQuaternionAndTranslation(
-                    transformStart.GetRotation().Slerp(transformEnd.GetRotation(), transitionTime),
-                    transformStart.GetTranslation().Lerp(transformEnd.GetTranslation(), transitionTime));
-
-                const AZ::Vector3 eulerAngles = AzFramework::EulerAngles(AZ::Matrix3x3::CreateFromTransform(current));
-                m_camera.m_pitch = eulerAngles.GetX();
-                m_camera.m_yaw = eulerAngles.GetZ();
-                m_camera.m_lookAt = current.GetTranslation();
-                m_targetCamera = m_camera;
-
-                if (animationTime >= 1.0f)
-                {
-                    m_cameraMode = CameraMode::Control;
-                }
-
-                m_cameraAnimation.m_time = AZ::GetClamp(animationTime + event.m_deltaTime.count(), 0.0f, 1.0f);
-
-                viewportContext->SetCameraTransform(current);
             }
 
-            m_updatingTransformInternally = false;
+            m_modularCameraViewportContext->SetCameraTransform(m_camera.Transform());
         }
+        else if (m_cameraMode == CameraMode::Animation)
+        {
+            const auto smootherStepFn = [](const float t)
+            {
+                return t * t * t * (t * (t * 6.0f - 15.0f) + 10.0f);
+            };
+
+            const auto& [transformStart, transformEnd, animationTime] = m_cameraAnimation;
+
+            const float transitionTime = smootherStepFn(animationTime);
+            const AZ::Transform current = AZ::Transform::CreateFromQuaternionAndTranslation(
+                transformStart.GetRotation().Slerp(transformEnd.GetRotation(), transitionTime),
+                transformStart.GetTranslation().Lerp(transformEnd.GetTranslation(), transitionTime));
+
+            const AZ::Vector3 eulerAngles = AzFramework::EulerAngles(AZ::Matrix3x3::CreateFromTransform(current));
+            m_camera.m_pitch = eulerAngles.GetX();
+            m_camera.m_yaw = eulerAngles.GetZ();
+            m_camera.m_lookAt = current.GetTranslation();
+            m_targetCamera = m_camera;
+
+            if (animationTime >= 1.0f)
+            {
+                m_cameraMode = CameraMode::Control;
+            }
+
+            m_cameraAnimation.m_time = AZ::GetClamp(animationTime + event.m_deltaTime.count(), 0.0f, 1.0f);
+
+            m_modularCameraViewportContext->SetCameraTransform(current);
+        }
+
+        m_updatingTransformInternally = false;
     }
 
     void ModularViewportCameraControllerInstance::DisplayViewport(

From e0b2027b42703cb540f263c89923880cba7c1b5a Mon Sep 17 00:00:00 2001
From: John <jonawals@amazon.com>
Date: Thu, 19 Aug 2021 11:16:14 +0100
Subject: [PATCH 36/37] Erase existing artifacts before generation.

Signed-off-by: John <jonawals@amazon.com>
---
 cmake/TestImpactFramework/LYTestImpactFramework.cmake | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/cmake/TestImpactFramework/LYTestImpactFramework.cmake b/cmake/TestImpactFramework/LYTestImpactFramework.cmake
index 7dd2617582..4b8ea226a1 100644
--- a/cmake/TestImpactFramework/LYTestImpactFramework.cmake
+++ b/cmake/TestImpactFramework/LYTestImpactFramework.cmake
@@ -448,8 +448,9 @@ function(ly_test_impact_post_step)
     # Directory for binaries built for this profile
     set(bin_dir "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/$<CONFIG>")
 
-    # Erase any existing non-persistent data to avoid getting test impact framework out of sync with current repo state
+    # Erase any existing artifact and non-persistent data to avoid getting test impact framework out of sync with current repo state
     file(REMOVE_RECURSE "${LY_TEST_IMPACT_TEMP_DIR}")
+    file(REMOVE_RECURSE "${LY_TEST_IMPACT_ARTIFACT_DIR}")
 
     # Export the soruce to target mapping files
     ly_test_impact_export_source_target_mappings(

From 6766d10d1be624e65f6e60a5ca8771c1b34da478 Mon Sep 17 00:00:00 2001
From: jiaweig <51759646+jiaweig-amzn@users.noreply.github.com>
Date: Thu, 19 Aug 2021 10:08:10 -0700
Subject: [PATCH 37/37] ATOM-13883 [RHI][Core] - Moving RHI init settings to
 the new settings registry system (#3086)

* Moved PlatformLimits to setreg. Removed Device PostInit. Some clean up.

Signed-off-by: jiaweig <jiaweig@amazon.com>

* Move setreg loading the PlatformLimitsDescriptor super class.

Signed-off-by: jiaweig <jiaweig@amazon.com>

* Apply same implementation for fake device used in unit tests

Signed-off-by: jiaweig <jiaweig@amazon.com>

* Add implementation for Null renderer. Swap order for register RHI interface in initialization.

Signed-off-by: jiaweig <jiaweig@amazon.com>

* Move back setreg from PlatfromLimitsDescriptor to Device, due to Linux dependency issue.

Signed-off-by: jiaweig <jiaweig@amazon.com>

* Changed the function to take in RHI backend name

Signed-off-by: jiaweig <jiaweig@amazon.com>
---
 .../Android/Vulkan/PlatformLimits.azasset     | 11 ----
 .../Linux/Vulkan/PlatformLimits.azasset       | 11 ----
 .../Platform/Mac/Metal/PlatformLimits.azasset | 12 -----
 .../Windows/DX12/PlatformLimits.azasset       | 18 -------
 .../Windows/Vulkan/PlatformLimits.azasset     | 11 ----
 .../Platform/iOS/Metal/PlatformLimits.azasset | 12 -----
 .../Atom/RHI.Reflect/DeviceDescriptor.h       |  4 +-
 .../RHI.Reflect/PlatformLimitsDescriptor.h    | 12 +++--
 .../Atom/RHI.Reflect/RHISystemDescriptor.h    |  2 -
 Gems/Atom/RHI/Code/Include/Atom/RHI/Device.h  | 17 +++---
 .../RHI/Code/Include/Atom/RHI/RHISystem.h     |  1 -
 .../Source/RHI.Reflect/DeviceDescriptor.cpp   |  6 +++
 .../RHI.Reflect/PlatformLimitsDescriptor.cpp  | 52 ++++++++++++-------
 Gems/Atom/RHI/Code/Source/RHI/Device.cpp      | 28 ++--------
 Gems/Atom/RHI/Code/Source/RHI/RHISystem.cpp   | 52 +++++++------------
 Gems/Atom/RHI/Code/Tests/Device.cpp           |  6 ++-
 Gems/Atom/RHI/Code/Tests/Device.h             |  7 ++-
 .../DX12/PlatformLimitsDescriptor.h           | 10 ++--
 .../RHI.Reflect/PlatformLimitsDescriptor.cpp  | 14 ++---
 Gems/Atom/RHI/DX12/Code/Source/RHI/Device.cpp | 36 +++++++------
 Gems/Atom/RHI/DX12/Code/Source/RHI/Device.h   |  4 +-
 .../Metal/PlatformLimitsDescriptor.h          |  6 +--
 .../RHI.Reflect/PlatformLimitsDescriptor.cpp  | 16 +++---
 .../Atom/RHI/Metal/Code/Source/RHI/Device.cpp | 18 +++++--
 Gems/Atom/RHI/Metal/Code/Source/RHI/Device.h  |  4 +-
 Gems/Atom/RHI/Null/Code/Source/RHI/Device.cpp |  5 ++
 Gems/Atom/RHI/Null/Code/Source/RHI/Device.h   |  6 +--
 .../Platform/Android/PlatformLimits.setreg    | 27 ++++++++++
 .../Platform/Linux/PlatformLimits.setreg      | 27 ++++++++++
 .../Platform/Mac/PlatformLimits.setreg        | 27 ++++++++++
 .../Platform/Windows/PlatformLimits.setreg    | 38 ++++++++++++++
 .../Platform/iOS/PlatformLimits.setreg        | 27 ++++++++++
 .../Vulkan/PlatformLimitsDescriptor.h         |  6 +--
 .../RHI.Reflect/PlatformLimitsDescriptor.cpp  | 14 ++---
 .../RHI/Vulkan/Code/Source/RHI/BufferPool.cpp |  2 +-
 .../RHI/Vulkan/Code/Source/RHI/Device.cpp     | 15 ++++--
 Gems/Atom/RHI/Vulkan/Code/Source/RHI/Device.h |  4 +-
 .../RPI/Code/Source/RPI.Public/RPISystem.cpp  | 13 -----
 .../RPI/Code/Tests/Common/RHI/Factory.cpp     |  1 -
 Gems/Atom/RPI/Code/Tests/Common/RHI/Stubs.cpp |  5 ++
 Gems/Atom/RPI/Code/Tests/Common/RHI/Stubs.h   |  3 +-
 41 files changed, 333 insertions(+), 257 deletions(-)
 delete mode 100644 Gems/Atom/Feature/Common/Assets/Config/Platform/Android/Vulkan/PlatformLimits.azasset
 delete mode 100644 Gems/Atom/Feature/Common/Assets/Config/Platform/Linux/Vulkan/PlatformLimits.azasset
 delete mode 100644 Gems/Atom/Feature/Common/Assets/Config/Platform/Mac/Metal/PlatformLimits.azasset
 delete mode 100644 Gems/Atom/Feature/Common/Assets/Config/Platform/Windows/DX12/PlatformLimits.azasset
 delete mode 100644 Gems/Atom/Feature/Common/Assets/Config/Platform/Windows/Vulkan/PlatformLimits.azasset
 delete mode 100644 Gems/Atom/Feature/Common/Assets/Config/Platform/iOS/Metal/PlatformLimits.azasset
 create mode 100644 Gems/Atom/RHI/Registry/Platform/Android/PlatformLimits.setreg
 create mode 100644 Gems/Atom/RHI/Registry/Platform/Linux/PlatformLimits.setreg
 create mode 100644 Gems/Atom/RHI/Registry/Platform/Mac/PlatformLimits.setreg
 create mode 100644 Gems/Atom/RHI/Registry/Platform/Windows/PlatformLimits.setreg
 create mode 100644 Gems/Atom/RHI/Registry/Platform/iOS/PlatformLimits.setreg

diff --git a/Gems/Atom/Feature/Common/Assets/Config/Platform/Android/Vulkan/PlatformLimits.azasset b/Gems/Atom/Feature/Common/Assets/Config/Platform/Android/Vulkan/PlatformLimits.azasset
deleted file mode 100644
index 37becd9eef..0000000000
--- a/Gems/Atom/Feature/Common/Assets/Config/Platform/Android/Vulkan/PlatformLimits.azasset
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-  "Type": "JsonSerialization",
-  "Version": 0,
-  "ClassName": "PlatformLimits",
-    "ClassData": {
-    "m_platformLimitsDescriptor": 
-    {
-      "$type": "Vulkan::PlatformLimitsDescriptor"
-    }
-  }
-}
diff --git a/Gems/Atom/Feature/Common/Assets/Config/Platform/Linux/Vulkan/PlatformLimits.azasset b/Gems/Atom/Feature/Common/Assets/Config/Platform/Linux/Vulkan/PlatformLimits.azasset
deleted file mode 100644
index 37becd9eef..0000000000
--- a/Gems/Atom/Feature/Common/Assets/Config/Platform/Linux/Vulkan/PlatformLimits.azasset
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-  "Type": "JsonSerialization",
-  "Version": 0,
-  "ClassName": "PlatformLimits",
-    "ClassData": {
-    "m_platformLimitsDescriptor": 
-    {
-      "$type": "Vulkan::PlatformLimitsDescriptor"
-    }
-  }
-}
diff --git a/Gems/Atom/Feature/Common/Assets/Config/Platform/Mac/Metal/PlatformLimits.azasset b/Gems/Atom/Feature/Common/Assets/Config/Platform/Mac/Metal/PlatformLimits.azasset
deleted file mode 100644
index 573862cc40..0000000000
--- a/Gems/Atom/Feature/Common/Assets/Config/Platform/Mac/Metal/PlatformLimits.azasset
+++ /dev/null
@@ -1,12 +0,0 @@
-{
-  "Type": "JsonSerialization",
-  "Version": 0,
-  "ClassName": "PlatformLimits",
-    "ClassData": {
-    "m_platformLimitsDescriptor": 
-    {
-      "$type": "Metal::PlatformLimitsDescriptor"
-    }
-  }
-}
- 
diff --git a/Gems/Atom/Feature/Common/Assets/Config/Platform/Windows/DX12/PlatformLimits.azasset b/Gems/Atom/Feature/Common/Assets/Config/Platform/Windows/DX12/PlatformLimits.azasset
deleted file mode 100644
index 3c88544e62..0000000000
--- a/Gems/Atom/Feature/Common/Assets/Config/Platform/Windows/DX12/PlatformLimits.azasset
+++ /dev/null
@@ -1,18 +0,0 @@
-{
-  "Type": "JsonSerialization",
-  "Version": 0,
-  "ClassName": "PlatformLimits",
-    "ClassData": {
-    "m_platformLimitsDescriptor": 
-    {
-      "$type": "DX12::PlatformLimitsDescriptor",
-      
-      "m_descriptorHeapLimits": {
-        "DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV": [1000000, 1000000],
-        "DESCRIPTOR_HEAP_TYPE_SAMPLER": [2048, 2048],
-        "DESCRIPTOR_HEAP_TYPE_RTV": [2048, 0],
-        "DESCRIPTOR_HEAP_TYPE_DSV": [2048, 0]
-      }
-    }
-  }
-}
diff --git a/Gems/Atom/Feature/Common/Assets/Config/Platform/Windows/Vulkan/PlatformLimits.azasset b/Gems/Atom/Feature/Common/Assets/Config/Platform/Windows/Vulkan/PlatformLimits.azasset
deleted file mode 100644
index 37becd9eef..0000000000
--- a/Gems/Atom/Feature/Common/Assets/Config/Platform/Windows/Vulkan/PlatformLimits.azasset
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-  "Type": "JsonSerialization",
-  "Version": 0,
-  "ClassName": "PlatformLimits",
-    "ClassData": {
-    "m_platformLimitsDescriptor": 
-    {
-      "$type": "Vulkan::PlatformLimitsDescriptor"
-    }
-  }
-}
diff --git a/Gems/Atom/Feature/Common/Assets/Config/Platform/iOS/Metal/PlatformLimits.azasset b/Gems/Atom/Feature/Common/Assets/Config/Platform/iOS/Metal/PlatformLimits.azasset
deleted file mode 100644
index 4556073118..0000000000
--- a/Gems/Atom/Feature/Common/Assets/Config/Platform/iOS/Metal/PlatformLimits.azasset
+++ /dev/null
@@ -1,12 +0,0 @@
-{
-  "Type": "JsonSerialization",
-  "Version": 0,
-  "ClassName": "PlatformLimits",
-    "ClassData": {
-    "m_platformLimitsDescriptor": 
-    {
-      "$type": "Metal::PlatformLimitsDescriptor"
-    }
-  }
-}
-
diff --git a/Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/DeviceDescriptor.h b/Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/DeviceDescriptor.h
index 87e2b03181..b7f7a6754f 100644
--- a/Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/DeviceDescriptor.h
+++ b/Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/DeviceDescriptor.h
@@ -22,14 +22,14 @@ namespace AZ
         class DeviceDescriptor
         {
         public:
-            virtual ~DeviceDescriptor() = default;
             AZ_RTTI(DeviceDescriptor, "{8446A34C-A079-44B8-A20F-45D9CAB1FAFD}");
             static void Reflect(AZ::ReflectContext* context);
 
             DeviceDescriptor() = default;
+            virtual ~DeviceDescriptor();
 
             uint32_t m_frameCountMax = RHI::Limits::Device::FrameCountMax;
-            ConstPtr<PlatformLimitsDescriptor> m_platformLimitsDescriptor = nullptr;
+            Ptr<PlatformLimitsDescriptor> m_platformLimitsDescriptor = nullptr;
         };
     }
 }
diff --git a/Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/PlatformLimitsDescriptor.h b/Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/PlatformLimitsDescriptor.h
index 4cec15651c..2d85420694 100644
--- a/Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/PlatformLimitsDescriptor.h
+++ b/Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/PlatformLimitsDescriptor.h
@@ -20,7 +20,7 @@ namespace AZ
     {
         struct TransientAttachmentPoolBudgets
         {
-            AZ_TYPE_INFO(TransientAttachmentPoolBudgets, "{CE39BBEF-C9CD-4B9A-BA41-C886D9F063BC}");
+            AZ_TYPE_INFO(AZ::RHI::TransientAttachmentPoolBudgets, "{CE39BBEF-C9CD-4B9A-BA41-C886D9F063BC}");
             static void Reflect(AZ::ReflectContext* context);
 
             //! Defines the maximum amount of memory the pool is allowed to consume for transient buffers.
@@ -53,8 +53,8 @@ namespace AZ
             : public AZStd::intrusive_base
         {
         public:
-            AZ_RTTI(PlatformLimitsDescriptor, "{3A7B2BE4-0337-4F59-B4FC-B7E529EBE6C5}");
-            AZ_CLASS_ALLOCATOR(PlatformLimitsDescriptor, AZ::SystemAllocator, 0);
+            AZ_RTTI(AZ::RHI::PlatformLimitsDescriptor, "{3A7B2BE4-0337-4F59-B4FC-B7E529EBE6C5}");
+            AZ_CLASS_ALLOCATOR(AZ::RHI::PlatformLimitsDescriptor, AZ::SystemAllocator, 0);
             static void Reflect(AZ::ReflectContext* context);
             static RHI::Ptr<PlatformLimitsDescriptor> Create();
 
@@ -67,13 +67,15 @@ namespace AZ
             HeapPagingParameters m_pagingParameters;
             HeapMemoryHintParameters m_usageHintParameters;
             HeapAllocationStrategy m_heapAllocationStrategy = HeapAllocationStrategy::MemoryHint;
+
+            void LoadPlatformLimitsDescriptor(const char* rhiName);
         };
 
         class PlatformLimits final
         {
         public:
-            AZ_RTTI(PlatformLimits, "{48158F25-5044-441C-A2B2-2D3E9255B0C3}");
-            AZ_CLASS_ALLOCATOR(PlatformLimits, AZ::SystemAllocator, 0);
+            AZ_RTTI(AZ::RHI::PlatformLimits, "{48158F25-5044-441C-A2B2-2D3E9255B0C3}");
+            AZ_CLASS_ALLOCATOR(AZ::RHI::PlatformLimits, AZ::SystemAllocator, 0);
             static void Reflect(AZ::ReflectContext* context);
 
             Ptr<PlatformLimitsDescriptor> m_platformLimitsDescriptor = nullptr;
diff --git a/Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/RHISystemDescriptor.h b/Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/RHISystemDescriptor.h
index b9fae5593f..8c512662e7 100644
--- a/Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/RHISystemDescriptor.h
+++ b/Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/RHISystemDescriptor.h
@@ -26,8 +26,6 @@ namespace AZ
 
             //! The set of globally declared draw list tags, which will be registered with the registry at startup.
             AZStd::vector<AZ::Name> m_drawListTags;
-
-            const RHI::PlatformLimits* m_platformLimits = nullptr;
         };
     } // namespace RHI
 } // namespace AZ
diff --git a/Gems/Atom/RHI/Code/Include/Atom/RHI/Device.h b/Gems/Atom/RHI/Code/Include/Atom/RHI/Device.h
index e7ad98c074..f9df29cf74 100644
--- a/Gems/Atom/RHI/Code/Include/Atom/RHI/Device.h
+++ b/Gems/Atom/RHI/Code/Include/Atom/RHI/Device.h
@@ -60,10 +60,6 @@ namespace AZ
             //! been called), and an error code is returned.
             ResultCode Init(PhysicalDevice& physicalDevice);
             
-            //! Called to initialize anything that wasn't done as part of Init. DeviceDescriptor is passed down
-            //! as part of this API. This is called after AssetCatalog is loaded and hence any file can be loaded at this point
-            ResultCode PostInit(const DeviceDescriptor& descriptor);
-
             //! Begins execution of a frame. The device internally manages a set of command queues. This
             //! method will synchronize the CPU with the GPU according to the number of in-light frames
             //! configured on the device. This means you should make sure any manipulation of N-buffered
@@ -147,7 +143,9 @@ namespace AZ
             DeviceFeatures m_features;
             DeviceLimits m_limits;
             ResourcePoolDatabase m_resourcePoolDatabase;
-            
+
+            DeviceDescriptor m_descriptor;
+
             using FormatCapabilitiesList = AZStd::array<FormatCapabilities, static_cast<uint32_t>(Format::Count)>;
 
         private:
@@ -165,10 +163,6 @@ namespace AZ
 
             //! Called when just the device is being initialized.
             virtual ResultCode InitInternal(PhysicalDevice& physicalDevice) = 0;
-             
-            //! Called to initialize anything that wasnt done as part of InitInternal.
-            //! This is called after AssetCatalog is loaded and hence any file can be loaded at this point
-            virtual ResultCode PostInitInternal(const DeviceDescriptor& descriptor) = 0;
 
             //! Called when the device is being shutdown.
             virtual void ShutdownInternal() = 0;
@@ -190,6 +184,9 @@ namespace AZ
 
             //! Fills the capabilities for each format.
             virtual void FillFormatsCapabilitiesInternal(FormatCapabilitiesList& formatsCapabilities) = 0;
+
+            //! Initialize limits and resources associated with them.
+            virtual ResultCode InitializeLimits() = 0;
             ///////////////////////////////////////////////////////////////////
 
             void CalculateDepthStencilNearestSupportedFormats();
@@ -198,8 +195,6 @@ namespace AZ
             //! All platform specific format mappings should be executed before this function is called
             void FillRemainingSupportedFormats();
 
-            DeviceDescriptor m_descriptor;
-
             // The physical device backing this logical device instance.
             Ptr<PhysicalDevice> m_physicalDevice;
 
diff --git a/Gems/Atom/RHI/Code/Include/Atom/RHI/RHISystem.h b/Gems/Atom/RHI/Code/Include/Atom/RHI/RHISystem.h
index e37fd75148..25026b5b87 100644
--- a/Gems/Atom/RHI/Code/Include/Atom/RHI/RHISystem.h
+++ b/Gems/Atom/RHI/Code/Include/Atom/RHI/RHISystem.h
@@ -68,7 +68,6 @@ namespace AZ
             RHI::FrameScheduler m_frameScheduler;
             RHI::FrameSchedulerCompileRequest m_compileRequest;
 
-            ConstPtr<PlatformLimitsDescriptor> m_platformLimitsDescriptor = nullptr;
             RHI::CpuProfilerImpl m_cpuProfiler;
         };
     } // namespace RPI
diff --git a/Gems/Atom/RHI/Code/Source/RHI.Reflect/DeviceDescriptor.cpp b/Gems/Atom/RHI/Code/Source/RHI.Reflect/DeviceDescriptor.cpp
index 709a870c81..8f36d38934 100644
--- a/Gems/Atom/RHI/Code/Source/RHI.Reflect/DeviceDescriptor.cpp
+++ b/Gems/Atom/RHI/Code/Source/RHI.Reflect/DeviceDescriptor.cpp
@@ -24,5 +24,11 @@ namespace AZ
                     ;
             }
         }
+
+        DeviceDescriptor::~DeviceDescriptor()
+        {
+            m_platformLimitsDescriptor = nullptr;
+        }
+
     }
 }
diff --git a/Gems/Atom/RHI/Code/Source/RHI.Reflect/PlatformLimitsDescriptor.cpp b/Gems/Atom/RHI/Code/Source/RHI.Reflect/PlatformLimitsDescriptor.cpp
index 02bcb3432f..250f03716d 100644
--- a/Gems/Atom/RHI/Code/Source/RHI.Reflect/PlatformLimitsDescriptor.cpp
+++ b/Gems/Atom/RHI/Code/Source/RHI.Reflect/PlatformLimitsDescriptor.cpp
@@ -7,6 +7,7 @@
  */
 #include <Atom/RHI.Reflect/PlatformLimitsDescriptor.h>
 #include <AzCore/Serialization/SerializeContext.h>
+#include <AzCore/Settings/SettingsRegistryImpl.h>
 
 namespace AZ
 {
@@ -17,8 +18,8 @@ namespace AZ
             if (auto* serializeContext = azrtti_cast<SerializeContext*>(context))
             {
                 serializeContext->Class<PlatformLimits>()
-                    ->Version(0)
-                    ->Field("m_platformLimitsDescriptor", &PlatformLimits::m_platformLimitsDescriptor)
+                    ->Version(1)
+                    ->Field("PlatformLimitsDescriptor", &PlatformLimits::m_platformLimitsDescriptor)
                     ;
             }
         }
@@ -28,10 +29,10 @@ namespace AZ
             if (auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
             {
                 serializeContext->Class<TransientAttachmentPoolBudgets>()
-                    ->Version(0)
-                    ->Field("m_bufferBudgetInBytes", &TransientAttachmentPoolBudgets::m_bufferBudgetInBytes)
-                    ->Field("m_imageBudgetInBytes", &TransientAttachmentPoolBudgets::m_imageBudgetInBytes)
-                    ->Field("m_renderTargetBudgetInBytes", &TransientAttachmentPoolBudgets::m_renderTargetBudgetInBytes)
+                    ->Version(1)
+                    ->Field("BufferBudgetInBytes", &TransientAttachmentPoolBudgets::m_bufferBudgetInBytes)
+                    ->Field("ImageBudgetInBytes", &TransientAttachmentPoolBudgets::m_imageBudgetInBytes)
+                    ->Field("RenderTargetBudgetInBytes", &TransientAttachmentPoolBudgets::m_renderTargetBudgetInBytes)
                     ;
             }
         }
@@ -41,13 +42,13 @@ namespace AZ
             if (auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
             {
                 serializeContext->Class<PlatformDefaultValues>()
-                    ->Version(0)
-                    ->Field("m_stagingBufferBudgetInBytes", &PlatformDefaultValues::m_stagingBufferBudgetInBytes)
-                    ->Field("m_asyncQueueStagingBufferSizeInBytes", &PlatformDefaultValues::m_asyncQueueStagingBufferSizeInBytes)
-                    ->Field("m_mediumStagingBufferPageSizeInBytes", &PlatformDefaultValues::m_mediumStagingBufferPageSizeInBytes)
-                    ->Field("m_largestStagingBufferPageSizeInBytes", &PlatformDefaultValues::m_largestStagingBufferPageSizeInBytes)
-                    ->Field("m_imagePoolPageSizeInBytes", &PlatformDefaultValues::m_imagePoolPageSizeInBytes)
-                    ->Field("m_bufferPoolPageSizeInBytes", &PlatformDefaultValues::m_bufferPoolPageSizeInBytes)
+                    ->Version(1)
+                    ->Field("StagingBufferBudgetInBytes", &PlatformDefaultValues::m_stagingBufferBudgetInBytes)
+                    ->Field("AsyncQueueStagingBufferSizeInBytes", &PlatformDefaultValues::m_asyncQueueStagingBufferSizeInBytes)
+                    ->Field("MediumStagingBufferPageSizeInBytes", &PlatformDefaultValues::m_mediumStagingBufferPageSizeInBytes)
+                    ->Field("LargestStagingBufferPageSizeInBytes", &PlatformDefaultValues::m_largestStagingBufferPageSizeInBytes)
+                    ->Field("ImagePoolPageSizeInBytes", &PlatformDefaultValues::m_imagePoolPageSizeInBytes)
+                    ->Field("BufferPoolPageSizeInBytes", &PlatformDefaultValues::m_bufferPoolPageSizeInBytes)
                     ;
             }
         }
@@ -58,12 +59,12 @@ namespace AZ
             if (auto* serializeContext = azrtti_cast<SerializeContext*>(context))
             {
                 serializeContext->Class<PlatformLimitsDescriptor>()
-                    ->Version(1)
-                    ->Field("m_transientAttachmentPoolBudgets", &PlatformLimitsDescriptor::m_transientAttachmentPoolBudgets)
-                    ->Field("m_platformDefaultValues", &PlatformLimitsDescriptor::m_platformDefaultValues)
-                    ->Field("m_pagingParameters", &PlatformLimitsDescriptor::m_pagingParameters)
-                    ->Field("m_usageHintParameters", &PlatformLimitsDescriptor::m_usageHintParameters)
-                    ->Field("m_heapAllocationStrategy", &PlatformLimitsDescriptor::m_heapAllocationStrategy)
+                    ->Version(2)
+                    ->Field("TransientAttachmentPoolBudgets", &PlatformLimitsDescriptor::m_transientAttachmentPoolBudgets)
+                    ->Field("PlatformDefaultValues", &PlatformLimitsDescriptor::m_platformDefaultValues)
+                    ->Field("PagingParameters", &PlatformLimitsDescriptor::m_pagingParameters)
+                    ->Field("UsageHintParameters", &PlatformLimitsDescriptor::m_usageHintParameters)
+                    ->Field("HeapAllocationStrategy", &PlatformLimitsDescriptor::m_heapAllocationStrategy)
                     ;
             }
         }
@@ -72,5 +73,18 @@ namespace AZ
         {
             return aznew PlatformLimitsDescriptor;
         }
+
+        void PlatformLimitsDescriptor::LoadPlatformLimitsDescriptor(const char* rhiName)
+        {
+            auto settingsRegistry = AZ::SettingsRegistry::Get();
+            AZStd::string platformLimitsRegPath = AZStd::string::format("/Amazon/Atom/RHI/PlatformLimits/%s", rhiName);
+            if (!(settingsRegistry &&
+                  settingsRegistry->GetObject(this, azrtti_typeid(this), platformLimitsRegPath.c_str())))
+            {
+                AZ_Warning(
+                    "Device", false, "Platform limits for %s %s is not loaded correctly. Will use default values.",
+                    AZ_TRAIT_OS_PLATFORM_NAME, rhiName);
+            }
+        }
     }
 }
diff --git a/Gems/Atom/RHI/Code/Source/RHI/Device.cpp b/Gems/Atom/RHI/Code/Source/RHI/Device.cpp
index b7a1e2315c..3af09717df 100644
--- a/Gems/Atom/RHI/Code/Source/RHI/Device.cpp
+++ b/Gems/Atom/RHI/Code/Source/RHI/Device.cpp
@@ -77,7 +77,7 @@ namespace AZ
             
             m_physicalDevice = &physicalDevice;
 
-            const ResultCode resultCode = InitInternal(physicalDevice);
+            RHI::ResultCode resultCode = InitInternal(physicalDevice);
 
             if (resultCode == ResultCode::Success)
             {
@@ -90,6 +90,9 @@ namespace AZ
 
                 // Assume all formats that haven't been mapped yet are supported and map to themselves
                 FillRemainingSupportedFormats();
+
+                // Initialize limits and resources that are associated with them
+                resultCode = InitializeLimits();
             }
             else
             {
@@ -98,29 +101,6 @@ namespace AZ
 
             return resultCode;
         }
-    
-        ResultCode Device::PostInit(const DeviceDescriptor& descriptor)
-        {
-            if (Validation::IsEnabled())
-            {
-                if (!IsInitialized())
-                {
-                    AZ_Error("Device", false, "Device is not initialized.");
-                    return ResultCode::InvalidOperation;
-                }
-            }
-
-            m_descriptor = descriptor;
-            const ResultCode resultCode = PostInitInternal(descriptor);
-
-            if (resultCode != ResultCode::Success)
-            {
-                AZ_Error("Device", false, "Device is not initialized.");
-                return ResultCode::InvalidOperation;
-            }
-
-            return resultCode;
-        }
 
         void Device::Shutdown()
         {
diff --git a/Gems/Atom/RHI/Code/Source/RHI/RHISystem.cpp b/Gems/Atom/RHI/Code/Source/RHI/RHISystem.cpp
index 5e08696ec2..8f8b7677fd 100644
--- a/Gems/Atom/RHI/Code/Source/RHI/RHISystem.cpp
+++ b/Gems/Atom/RHI/Code/Source/RHI/RHISystem.cpp
@@ -30,42 +30,26 @@ namespace AZ
 
         void RHISystem::InitDevice()
         {
-            m_device = InitInternalDevice();
             Interface<RHISystemInterface>::Register(this);
+            m_device = InitInternalDevice();
         }
     
         void RHISystem::Init(const RHISystemDescriptor& descriptor)
         {
             m_cpuProfiler.Init();
 
+            Ptr<RHI::PlatformLimitsDescriptor> platformLimitsDescriptor = m_device->GetDescriptor().m_platformLimitsDescriptor;
+
             RHI::FrameSchedulerDescriptor frameSchedulerDescriptor;
-            if (descriptor.m_platformLimits)
-            {
-                m_platformLimitsDescriptor = descriptor.m_platformLimits->m_platformLimitsDescriptor;
-            }
-
-            //If platformlimits.azasset file is not provided create an object with default config values.
-            if (!m_platformLimitsDescriptor)
-            {
-                m_platformLimitsDescriptor = PlatformLimitsDescriptor::Create();
-            }
-
-            RHI::DeviceDescriptor deviceDesc;
-            deviceDesc.m_platformLimitsDescriptor = m_platformLimitsDescriptor;
-            if (m_device->PostInit(deviceDesc) != RHI::ResultCode::Success)
-            {
-                AZ_Assert(false, "RHISystem", "Unable to initialize RHI! \n");
-                return;
-            }
 
             m_drawListTagRegistry = RHI::DrawListTagRegistry::Create();
             m_pipelineStateCache = RHI::PipelineStateCache::Create(*m_device);
 
-            frameSchedulerDescriptor.m_transientAttachmentPoolDescriptor.m_renderTargetBudgetInBytes = m_platformLimitsDescriptor->m_transientAttachmentPoolBudgets.m_renderTargetBudgetInBytes;
-            frameSchedulerDescriptor.m_transientAttachmentPoolDescriptor.m_imageBudgetInBytes = m_platformLimitsDescriptor->m_transientAttachmentPoolBudgets.m_imageBudgetInBytes;
-            frameSchedulerDescriptor.m_transientAttachmentPoolDescriptor.m_bufferBudgetInBytes = m_platformLimitsDescriptor->m_transientAttachmentPoolBudgets.m_bufferBudgetInBytes;
+            frameSchedulerDescriptor.m_transientAttachmentPoolDescriptor.m_renderTargetBudgetInBytes = platformLimitsDescriptor->m_transientAttachmentPoolBudgets.m_renderTargetBudgetInBytes;
+            frameSchedulerDescriptor.m_transientAttachmentPoolDescriptor.m_imageBudgetInBytes = platformLimitsDescriptor->m_transientAttachmentPoolBudgets.m_imageBudgetInBytes;
+            frameSchedulerDescriptor.m_transientAttachmentPoolDescriptor.m_bufferBudgetInBytes = platformLimitsDescriptor->m_transientAttachmentPoolBudgets.m_bufferBudgetInBytes;
 
-            switch (m_platformLimitsDescriptor->m_heapAllocationStrategy)
+            switch (platformLimitsDescriptor->m_heapAllocationStrategy)
             {
                 case HeapAllocationStrategy::Fixed:
                 {
@@ -75,19 +59,19 @@ namespace AZ
                 case  HeapAllocationStrategy::Paging:
                 {
                     RHI::HeapPagingParameters heapAllocationParameters;
-                    heapAllocationParameters.m_collectLatency = m_platformLimitsDescriptor->m_pagingParameters.m_collectLatency;
-                    heapAllocationParameters.m_initialAllocationPercentage = m_platformLimitsDescriptor->m_pagingParameters.m_initialAllocationPercentage;
-                    heapAllocationParameters.m_pageSizeInBytes = m_platformLimitsDescriptor->m_pagingParameters.m_pageSizeInBytes;
+                    heapAllocationParameters.m_collectLatency = platformLimitsDescriptor->m_pagingParameters.m_collectLatency;
+                    heapAllocationParameters.m_initialAllocationPercentage = platformLimitsDescriptor->m_pagingParameters.m_initialAllocationPercentage;
+                    heapAllocationParameters.m_pageSizeInBytes = platformLimitsDescriptor->m_pagingParameters.m_pageSizeInBytes;
                     frameSchedulerDescriptor.m_transientAttachmentPoolDescriptor.m_heapParameters = RHI::HeapAllocationParameters(heapAllocationParameters);
                     break;
                 }
                 case HeapAllocationStrategy::MemoryHint:
                 {
                     RHI::HeapMemoryHintParameters heapAllocationParameters;
-                    heapAllocationParameters.m_heapSizeScaleFactor = m_platformLimitsDescriptor->m_usageHintParameters.m_heapSizeScaleFactor;
-                    heapAllocationParameters.m_collectLatency = m_platformLimitsDescriptor->m_usageHintParameters.m_collectLatency;
-                    heapAllocationParameters.m_maxHeapWastedPercentage = m_platformLimitsDescriptor->m_usageHintParameters.m_maxHeapWastedPercentage;
-                    heapAllocationParameters.m_minHeapSizeInBytes = m_platformLimitsDescriptor->m_usageHintParameters.m_minHeapSizeInBytes;
+                    heapAllocationParameters.m_heapSizeScaleFactor = platformLimitsDescriptor->m_usageHintParameters.m_heapSizeScaleFactor;
+                    heapAllocationParameters.m_collectLatency = platformLimitsDescriptor->m_usageHintParameters.m_collectLatency;
+                    heapAllocationParameters.m_maxHeapWastedPercentage = platformLimitsDescriptor->m_usageHintParameters.m_maxHeapWastedPercentage;
+                    heapAllocationParameters.m_minHeapSizeInBytes = platformLimitsDescriptor->m_usageHintParameters.m_minHeapSizeInBytes;
                     frameSchedulerDescriptor.m_transientAttachmentPoolDescriptor.m_heapParameters = RHI::HeapAllocationParameters(heapAllocationParameters);
                     break;
                 }
@@ -98,7 +82,7 @@ namespace AZ
                 }
             }
                 
-            frameSchedulerDescriptor.m_platformLimitsDescriptor = m_platformLimitsDescriptor;
+            frameSchedulerDescriptor.m_platformLimitsDescriptor = platformLimitsDescriptor;
             m_frameScheduler.Init(*m_device, frameSchedulerDescriptor);
 
             // Register draw list tags declared from content.
@@ -183,6 +167,7 @@ namespace AZ
             RHI::Ptr<RHI::Device> device = RHI::Factory::Get().CreateDevice();
             if (device->Init(*physicalDeviceFound) == RHI::ResultCode::Success)
             {
+                PlatformLimitsDescriptor::Create();
                 return device;
             }
 
@@ -195,10 +180,9 @@ namespace AZ
             Interface<RHISystemInterface>::Unregister(this);
             m_frameScheduler.Shutdown();
 
-            m_platformLimitsDescriptor = nullptr;
             m_pipelineStateCache = nullptr;
             if (m_device)
-            {            
+            {
                 m_device->PreShutdown();
                 AZ_Assert(m_device->use_count()==1, "The ref count for Device is %i but it should be 1 here to ensure all the resources are released", m_device->use_count());
                 m_device = nullptr;
@@ -293,7 +277,7 @@ namespace AZ
 
         ConstPtr<PlatformLimitsDescriptor> RHISystem::GetPlatformLimitsDescriptor() const
         {
-            return m_platformLimitsDescriptor;
+            return m_device->GetDescriptor().m_platformLimitsDescriptor;
         }
 
         void RHISystem::QueueRayTracingShaderTableForBuild(RayTracingShaderTable* rayTracingShaderTable)
diff --git a/Gems/Atom/RHI/Code/Tests/Device.cpp b/Gems/Atom/RHI/Code/Tests/Device.cpp
index 654653ceb9..0f424a5405 100644
--- a/Gems/Atom/RHI/Code/Tests/Device.cpp
+++ b/Gems/Atom/RHI/Code/Tests/Device.cpp
@@ -17,6 +17,11 @@ namespace UnitTest
         m_descriptor.m_description = "UnitTest Fake Device";
     }
 
+    Device::Device()
+    {
+        m_descriptor.m_platformLimitsDescriptor = aznew RHI::PlatformLimitsDescriptor;
+    }
+
     RHI::PhysicalDeviceList PhysicalDevice::Enumerate()
     {
         return RHI::PhysicalDeviceList{aznew PhysicalDevice};
@@ -29,7 +34,6 @@ namespace UnitTest
 
         RHI::Ptr<RHI::Device> device = RHI::Factory::Get().CreateDevice();
         device->Init(*physicalDevices[0]);
-        device->PostInit(RHI::DeviceDescriptor{});
 
         return device;
     }
diff --git a/Gems/Atom/RHI/Code/Tests/Device.h b/Gems/Atom/RHI/Code/Tests/Device.h
index e11bd75983..d3177fc823 100644
--- a/Gems/Atom/RHI/Code/Tests/Device.h
+++ b/Gems/Atom/RHI/Code/Tests/Device.h
@@ -31,10 +31,11 @@ namespace UnitTest
     public:
         AZ_CLASS_ALLOCATOR(Device, AZ::SystemAllocator, 0);
 
+        Device();
+
     private:
 
         AZ::RHI::ResultCode InitInternal(AZ::RHI::PhysicalDevice&) override { return AZ::RHI::ResultCode::Success; }
-        AZ::RHI::ResultCode PostInitInternal(const AZ::RHI::DeviceDescriptor&) override { return AZ::RHI::ResultCode::Success; }
 
         void ShutdownInternal() override {}
 
@@ -54,7 +55,9 @@ namespace UnitTest
         }
 
         void FillFormatsCapabilitiesInternal([[maybe_unused]] FormatCapabilitiesList& formatsCapabilities) override {}
-        
+
+        AZ::RHI::ResultCode InitializeLimits() override { return AZ::RHI::ResultCode::Success; }
+
         void PreShutdown() override {}
 
         AZ::RHI::ResourceMemoryRequirements GetResourceMemoryRequirements([[maybe_unused]] const AZ::RHI::ImageDescriptor& descriptor) { return AZ::RHI::ResourceMemoryRequirements{}; };
diff --git a/Gems/Atom/RHI/DX12/Code/Include/Atom/RHI.Reflect/DX12/PlatformLimitsDescriptor.h b/Gems/Atom/RHI/DX12/Code/Include/Atom/RHI.Reflect/DX12/PlatformLimitsDescriptor.h
index 06e15d0ca6..cbf1fd11f6 100644
--- a/Gems/Atom/RHI/DX12/Code/Include/Atom/RHI.Reflect/DX12/PlatformLimitsDescriptor.h
+++ b/Gems/Atom/RHI/DX12/Code/Include/Atom/RHI.Reflect/DX12/PlatformLimitsDescriptor.h
@@ -23,11 +23,11 @@ namespace AZ
             DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV,
             DESCRIPTOR_HEAP_TYPE_SAMPLER,
             DESCRIPTOR_HEAP_TYPE_RTV,
-            DESCRIPTOR_HEAP_TYPE_DSV);     
+            DESCRIPTOR_HEAP_TYPE_DSV);
 
         struct FrameGraphExecuterData
         {
-            AZ_TYPE_INFO(FrameGraphExecuterData, "{C21547F6-DE48-4F82-B812-1A187101AB4E}");
+            AZ_TYPE_INFO(AZ::DX12::FrameGraphExecuterData, "{C21547F6-DE48-4F82-B812-1A187101AB4E}");
             static void Reflect(AZ::ReflectContext* context);
 
             //Cost per draw/dispatch item
@@ -52,15 +52,15 @@ namespace AZ
         {
             using Base = RHI::PlatformLimitsDescriptor;
         public:
-            AZ_RTTI(DX12::PlatformLimitsDescriptor, "{ADCC8071-FCE4-4FA1-A048-DF8982951A0D}", Base);
-            AZ_CLASS_ALLOCATOR(PlatformLimitsDescriptor, AZ::SystemAllocator, 0);
+            AZ_RTTI(AZ::DX12::PlatformLimitsDescriptor, "{ADCC8071-FCE4-4FA1-A048-DF8982951A0D}", Base);
+            AZ_CLASS_ALLOCATOR(AZ::DX12::PlatformLimitsDescriptor, AZ::SystemAllocator, 0);
             static void Reflect(AZ::ReflectContext* context);
 
             PlatformLimitsDescriptor() = default;
 
             static const uint32_t NumHeapFlags = 2;// D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE + 1;
 
-            //! string key: stringifed version of DESCRIPTOR_HEAP_TYPE.
+            //! string key: string version of DESCRIPTOR_HEAP_TYPE.
             //! int array: Max count for descriptors 
             AZStd::unordered_map<AZStd::string, AZStd::array<uint32_t, NumHeapFlags>> m_descriptorHeapLimits;
 
diff --git a/Gems/Atom/RHI/DX12/Code/Source/RHI.Reflect/PlatformLimitsDescriptor.cpp b/Gems/Atom/RHI/DX12/Code/Source/RHI.Reflect/PlatformLimitsDescriptor.cpp
index 3c685051ea..980264aa9b 100644
--- a/Gems/Atom/RHI/DX12/Code/Source/RHI.Reflect/PlatformLimitsDescriptor.cpp
+++ b/Gems/Atom/RHI/DX12/Code/Source/RHI.Reflect/PlatformLimitsDescriptor.cpp
@@ -19,8 +19,8 @@ namespace AZ
             {
                 serializeContext->Class<PlatformLimitsDescriptor, Base>()
                     ->Version(0)
-                    ->Field("m_descriptorHeapLimits", &PlatformLimitsDescriptor::m_descriptorHeapLimits)
-                    ->Field("m_frameGraphExecuterData", &PlatformLimitsDescriptor::m_frameGraphExecuterData)
+                    ->Field("DescriptorHeapLimits", &PlatformLimitsDescriptor::m_descriptorHeapLimits)
+                    ->Field("FrameGraphExecuterData", &PlatformLimitsDescriptor::m_frameGraphExecuterData)
                     ;
             }
         }
@@ -31,11 +31,11 @@ namespace AZ
             {
                 serializeContext->Class<FrameGraphExecuterData>()
                     ->Version(0)
-                    ->Field("m_itemCost", &FrameGraphExecuterData::m_itemCost)
-                    ->Field("m_attachmentCost", &FrameGraphExecuterData::m_attachmentCost)
-                    ->Field("m_swapChainsPerCommandList", &FrameGraphExecuterData::m_swapChainsPerCommandList)
-                    ->Field("m_commandListCostThresholdMin", &FrameGraphExecuterData::m_commandListCostThresholdMin)
-                    ->Field("m_commandListsPerScopeMax", &FrameGraphExecuterData::m_commandListsPerScopeMax)
+                    ->Field("ItemCost", &FrameGraphExecuterData::m_itemCost)
+                    ->Field("AttachmentCost", &FrameGraphExecuterData::m_attachmentCost)
+                    ->Field("SwapChainsPerCommandList", &FrameGraphExecuterData::m_swapChainsPerCommandList)
+                    ->Field("CommandListCostThresholdMin", &FrameGraphExecuterData::m_commandListCostThresholdMin)
+                    ->Field("CommandListsPerScopeMax", &FrameGraphExecuterData::m_commandListsPerScopeMax)
                     ;
             }
         }
diff --git a/Gems/Atom/RHI/DX12/Code/Source/RHI/Device.cpp b/Gems/Atom/RHI/DX12/Code/Source/RHI/Device.cpp
index 9d23dfa43d..30ed07bd22 100644
--- a/Gems/Atom/RHI/DX12/Code/Source/RHI/Device.cpp
+++ b/Gems/Atom/RHI/DX12/Code/Source/RHI/Device.cpp
@@ -5,6 +5,7 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
+#include <Atom/RHI/Factory.h>
 #include <Atom/RHI/RHISystemInterface.h>
 #include <RHI/Device.h>
 #include <RHI/PhysicalDevice.h>
@@ -29,6 +30,13 @@ namespace AZ
             void DeviceCompileMemoryStatisticsInternal(RHI::MemoryStatisticsBuilder& builder, IDXGIAdapterX* dxgiAdapter);
         }
 
+        Device::Device()
+        {
+            RHI::Ptr<PlatformLimitsDescriptor> platformLimitsDescriptor = aznew PlatformLimitsDescriptor();
+            platformLimitsDescriptor->LoadPlatformLimitsDescriptor(RHI::Factory::Get().GetName().GetCStr());
+            m_descriptor.m_platformLimitsDescriptor = RHI::Ptr<RHI::PlatformLimitsDescriptor>(platformLimitsDescriptor);
+        }
+
         RHI::Ptr<Device> Device::Create()
         {
             return aznew Device();
@@ -43,35 +51,31 @@ namespace AZ
             }
 
             InitFeatures();
+
             return RHI::ResultCode::Success;
         }
 
-        RHI::ResultCode Device::PostInitInternal(const RHI::DeviceDescriptor& descriptor)
+        RHI::ResultCode Device::InitializeLimits()
         {
             m_allocationInfoCache.SetInitFunction([](auto& cache) { cache.set_capacity(64); });
 
             {
                 ReleaseQueue::Descriptor releaseQueueDescriptor;
-                releaseQueueDescriptor.m_collectLatency = descriptor.m_frameCountMax - 1;
+                releaseQueueDescriptor.m_collectLatency = m_descriptor.m_frameCountMax - 1;
                 m_releaseQueue.Init(releaseQueueDescriptor);
             }
 
             m_descriptorContext = AZStd::make_shared<DescriptorContext>();
 
-            RHI::ConstPtr<RHI::PlatformLimitsDescriptor> rhiDescriptor = descriptor.m_platformLimitsDescriptor;
-            if (RHI::ConstPtr<PlatformLimitsDescriptor> platLimitsDesc = azrtti_cast<const PlatformLimitsDescriptor*>(rhiDescriptor))
-            {
-                m_descriptorContext->Init(m_dx12Device.get(), platLimitsDesc);
-            }
-            else
-            {
-                AZ_Assert(false, "Missing PlatformLimits config file for DX12 backend");
-            }
+            RHI::ConstPtr<RHI::PlatformLimitsDescriptor> rhiDescriptor = m_descriptor.m_platformLimitsDescriptor;
+            RHI::ConstPtr<PlatformLimitsDescriptor> platLimitsDesc = azrtti_cast<const PlatformLimitsDescriptor*>(rhiDescriptor);
+            AZ_Assert(platLimitsDesc != nullptr, "Missing PlatformLimits config file for DX12 backend");
+            m_descriptorContext->Init(m_dx12Device.get(), platLimitsDesc);
 
             {
                 CommandListAllocator::Descriptor commandListAllocatorDescriptor;
                 commandListAllocatorDescriptor.m_device = this;
-                commandListAllocatorDescriptor.m_frameCountMax = descriptor.m_frameCountMax;
+                commandListAllocatorDescriptor.m_frameCountMax = m_descriptor.m_frameCountMax;
                 commandListAllocatorDescriptor.m_descriptorContext = m_descriptorContext;
                 m_commandListAllocator.Init(commandListAllocatorDescriptor);
             }
@@ -80,9 +84,9 @@ namespace AZ
                 StagingMemoryAllocator::Descriptor allocatorDesc;
                 allocatorDesc.m_device = this;
 
-                allocatorDesc.m_mediumPageSizeInBytes = RHI::RHISystemInterface::Get()->GetPlatformLimitsDescriptor()->m_platformDefaultValues.m_mediumStagingBufferPageSizeInBytes;
-                allocatorDesc.m_largePageSizeInBytes = RHI::RHISystemInterface::Get()->GetPlatformLimitsDescriptor()->m_platformDefaultValues.m_largestStagingBufferPageSizeInBytes;
-                allocatorDesc.m_collectLatency = descriptor.m_frameCountMax;
+                allocatorDesc.m_mediumPageSizeInBytes = platLimitsDesc->m_platformDefaultValues.m_mediumStagingBufferPageSizeInBytes;
+                allocatorDesc.m_largePageSizeInBytes = platLimitsDesc->m_platformDefaultValues.m_largestStagingBufferPageSizeInBytes;
+                allocatorDesc.m_collectLatency = m_descriptor.m_frameCountMax;
                 m_stagingMemoryAllocator.Init(allocatorDesc);
             }
 
@@ -90,7 +94,7 @@ namespace AZ
 
             m_commandQueueContext.Init(*this);
 
-            m_asyncUploadQueue.Init(*this, AsyncUploadQueue::Descriptor(RHI::RHISystemInterface::Get()->GetPlatformLimitsDescriptor()->m_platformDefaultValues.m_asyncQueueStagingBufferSizeInBytes));
+            m_asyncUploadQueue.Init(*this, AsyncUploadQueue::Descriptor(platLimitsDesc->m_platformDefaultValues.m_asyncQueueStagingBufferSizeInBytes));
 
             m_samplerCache.SetCapacity(SamplerCacheCapacity);
 
diff --git a/Gems/Atom/RHI/DX12/Code/Source/RHI/Device.h b/Gems/Atom/RHI/DX12/Code/Source/RHI/Device.h
index 9119545342..4d1f2c4ac9 100644
--- a/Gems/Atom/RHI/DX12/Code/Source/RHI/Device.h
+++ b/Gems/Atom/RHI/DX12/Code/Source/RHI/Device.h
@@ -143,12 +143,11 @@ namespace AZ
 
             bool IsAftermathInitialized() const;
         private:
-            Device() = default;
+            Device();
 
             //////////////////////////////////////////////////////////////////////////
             // RHI::Device
             RHI::ResultCode InitInternal(RHI::PhysicalDevice& physicalDevice) override;
-            RHI::ResultCode PostInitInternal(const RHI::DeviceDescriptor & params) override;
 
             void ShutdownInternal() override;
             void CompileMemoryStatisticsInternal(RHI::MemoryStatisticsBuilder& builder) override;
@@ -158,6 +157,7 @@ namespace AZ
             void WaitForIdleInternal() override;
             AZStd::chrono::microseconds GpuTimestampToMicroseconds(uint64_t gpuTimestamp, RHI::HardwareQueueClass queueClass) const override;
             void FillFormatsCapabilitiesInternal(FormatCapabilitiesList& formatsCapabilities) override;
+            RHI::ResultCode InitializeLimits() override;
             AZStd::vector<RHI::Format> GetValidSwapChainImageFormats(const RHI::WindowHandle& windowHandle) const override;
             void PreShutdown() override;
             RHI::ResourceMemoryRequirements GetResourceMemoryRequirements(const RHI::ImageDescriptor & descriptor) override;
diff --git a/Gems/Atom/RHI/Metal/Code/Include/Atom/RHI.Reflect/Metal/PlatformLimitsDescriptor.h b/Gems/Atom/RHI/Metal/Code/Include/Atom/RHI.Reflect/Metal/PlatformLimitsDescriptor.h
index ace3e08142..375b532d39 100644
--- a/Gems/Atom/RHI/Metal/Code/Include/Atom/RHI.Reflect/Metal/PlatformLimitsDescriptor.h
+++ b/Gems/Atom/RHI/Metal/Code/Include/Atom/RHI.Reflect/Metal/PlatformLimitsDescriptor.h
@@ -18,7 +18,7 @@ namespace AZ
     {
         struct FrameGraphExecuterData
         {
-            AZ_TYPE_INFO(FrameGraphExecuterData, "{BD831EFB-CC74-46F8-BE48-118B2E8F07D0}");
+            AZ_TYPE_INFO(AZ::Metal::FrameGraphExecuterData, "{BD831EFB-CC74-46F8-BE48-118B2E8F07D0}");
             static void Reflect(AZ::ReflectContext* context);
 
             //Cost per draw/dispatch item
@@ -43,8 +43,8 @@ namespace AZ
         {
             using Base = RHI::PlatformLimitsDescriptor;
         public:
-            AZ_RTTI(Metal::PlatformLimitsDescriptor, "{B89F116F-9FEF-4BCA-9EC7-9FF8F772B7FD}", Base);
-            AZ_CLASS_ALLOCATOR(PlatformLimitsDescriptor, AZ::SystemAllocator, 0);
+            AZ_RTTI(AZ::Metal::PlatformLimitsDescriptor, "{B89F116F-9FEF-4BCA-9EC7-9FF8F772B7FD}", Base);
+            AZ_CLASS_ALLOCATOR(AZ::Metal::PlatformLimitsDescriptor, AZ::SystemAllocator, 0);
             static void Reflect(AZ::ReflectContext* context);
 
             FrameGraphExecuterData m_frameGraphExecuterData;
diff --git a/Gems/Atom/RHI/Metal/Code/Source/RHI.Reflect/PlatformLimitsDescriptor.cpp b/Gems/Atom/RHI/Metal/Code/Source/RHI.Reflect/PlatformLimitsDescriptor.cpp
index bdf405d157..4788244775 100644
--- a/Gems/Atom/RHI/Metal/Code/Source/RHI.Reflect/PlatformLimitsDescriptor.cpp
+++ b/Gems/Atom/RHI/Metal/Code/Source/RHI.Reflect/PlatformLimitsDescriptor.cpp
@@ -18,8 +18,8 @@ namespace AZ
             if (SerializeContext* serializeContext = azrtti_cast<SerializeContext*>(context))
             {
                 serializeContext->Class<PlatformLimitsDescriptor, Base>()
-                    ->Version(0)
-                    ->Field("m_frameGraphExecuterData", &PlatformLimitsDescriptor::m_frameGraphExecuterData)
+                    ->Version(1)
+                    ->Field("FrameGraphExecuterData", &PlatformLimitsDescriptor::m_frameGraphExecuterData)
                     ;
             }
         }
@@ -29,12 +29,12 @@ namespace AZ
             if (auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
             {
                 serializeContext->Class<FrameGraphExecuterData>()
-                    ->Version(0)
-                    ->Field("m_itemCost", &FrameGraphExecuterData::m_itemCost)
-                    ->Field("m_attachmentCost", &FrameGraphExecuterData::m_attachmentCost)
-                    ->Field("m_swapChainsPerCommandList", &FrameGraphExecuterData::m_swapChainsPerCommandList)
-                    ->Field("m_commandListCostThresholdMin", &FrameGraphExecuterData::m_commandListCostThresholdMin)
-                    ->Field("m_commandListsPerScopeMax", &FrameGraphExecuterData::m_commandListsPerScopeMax)
+                    ->Version(1)
+                    ->Field("ItemCost", &FrameGraphExecuterData::m_itemCost)
+                    ->Field("AttachmentCost", &FrameGraphExecuterData::m_attachmentCost)
+                    ->Field("SwapChainsPerCommandList", &FrameGraphExecuterData::m_swapChainsPerCommandList)
+                    ->Field("CommandListCostThresholdMin", &FrameGraphExecuterData::m_commandListCostThresholdMin)
+                    ->Field("CommandListsPerScopeMax", &FrameGraphExecuterData::m_commandListsPerScopeMax)
                     ;
             }
         }
diff --git a/Gems/Atom/RHI/Metal/Code/Source/RHI/Device.cpp b/Gems/Atom/RHI/Metal/Code/Source/RHI/Device.cpp
index 5591bcc843..782ea7174b 100644
--- a/Gems/Atom/RHI/Metal/Code/Source/RHI/Device.cpp
+++ b/Gems/Atom/RHI/Metal/Code/Source/RHI/Device.cpp
@@ -5,7 +5,9 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
+#include <Atom/RHI/Factory.h>
 #include <Atom/RHI/RHISystemInterface.h>
+#include <Atom/RHI.Reflect/Metal/PlatformLimitsDescriptor.h>
 #include <AzCore/Debug/EventTrace.h>
 #include <AzFramework/API/ApplicationAPI.h>
 #include <AzFramework/Components/TransformComponent.h>
@@ -27,6 +29,13 @@ namespace AZ
 {
     namespace Metal
     {
+        Device::Device()
+        {
+            RHI::Ptr<PlatformLimitsDescriptor> platformLimitsDescriptor = aznew PlatformLimitsDescriptor();
+            platformLimitsDescriptor->LoadPlatformLimitsDescriptor(RHI::Factory::Get().GetName().GetCStr());
+            m_descriptor.m_platformLimitsDescriptor = RHI::Ptr<RHI::PlatformLimitsDescriptor>(platformLimitsDescriptor);
+        }
+
         RHI::Ptr<Device> Device::Create()
         {
             return aznew Device();
@@ -42,24 +51,24 @@ namespace AZ
             return RHI::ResultCode::Success;
         }
 
-        RHI::ResultCode Device::PostInitInternal(const RHI::DeviceDescriptor& descriptor)
+        RHI::ResultCode Device::InitializeLimits()
         {
             {
                 ReleaseQueue::Descriptor releaseQueueDescriptor;
-                releaseQueueDescriptor.m_collectLatency = descriptor.m_frameCountMax;
+                releaseQueueDescriptor.m_collectLatency = m_descriptor.m_frameCountMax;
                 m_releaseQueue.Init(releaseQueueDescriptor);
             }
              
             {
                 CommandListAllocator::Descriptor commandListAllocatorDescriptor;
-                commandListAllocatorDescriptor.m_frameCountMax = descriptor.m_frameCountMax;
+                commandListAllocatorDescriptor.m_frameCountMax = m_descriptor.m_frameCountMax;
                 m_commandListAllocator.Init(commandListAllocatorDescriptor, this);
             }
 
             m_pipelineLayoutCache.Init(*this);
             m_commandQueueContext.Init(*this);
 
-            m_asyncUploadQueue.Init(*this, AsyncUploadQueue::Descriptor(RHI::RHISystemInterface::Get()->GetPlatformLimitsDescriptor()->m_platformDefaultValues.m_asyncQueueStagingBufferSizeInBytes));
+            m_asyncUploadQueue.Init(*this, AsyncUploadQueue::Descriptor(m_descriptor.m_platformLimitsDescriptor->m_platformDefaultValues.m_asyncQueueStagingBufferSizeInBytes));
 
             BufferMemoryAllocator::Descriptor allocatorDescriptor;
             allocatorDescriptor.m_device = this;
@@ -77,6 +86,7 @@ namespace AZ
             
             m_samplerCache = [[NSCache alloc]init];
             [m_samplerCache setName:@"SamplerCache"];
+
             return RHI::ResultCode::Success;
         }
     
diff --git a/Gems/Atom/RHI/Metal/Code/Source/RHI/Device.h b/Gems/Atom/RHI/Metal/Code/Source/RHI/Device.h
index 9cdeee7eae..90dd4ff4a0 100644
--- a/Gems/Atom/RHI/Metal/Code/Source/RHI/Device.h
+++ b/Gems/Atom/RHI/Metal/Code/Source/RHI/Device.h
@@ -154,12 +154,11 @@ namespace AZ
             void ObjectCollectionNotify(RHI::ObjectCollectorNotifyFunction notifyFunction) override;
 
         private:
-            Device() = default;
+            Device();
             
             //////////////////////////////////////////////////////////////////////////
             // RHI::Device
             RHI::ResultCode InitInternal(RHI::PhysicalDevice& physicalDevice) override;
-            RHI::ResultCode PostInitInternal(const RHI::DeviceDescriptor& params) override;
             void ShutdownInternal() override;
             void CompileMemoryStatisticsInternal(RHI::MemoryStatisticsBuilder& builder) override;
             void UpdateCpuTimingStatisticsInternal(RHI::CpuTimingStatistics& cpuTimingStatistics) const override;
@@ -168,6 +167,7 @@ namespace AZ
             void WaitForIdleInternal() override;
             AZStd::chrono::microseconds GpuTimestampToMicroseconds(uint64_t gpuTimestamp, RHI::HardwareQueueClass queueClass) const override;
             void FillFormatsCapabilitiesInternal(FormatCapabilitiesList& formatsCapabilities) override;
+            RHI::ResultCode InitializeLimits() override;
             void PreShutdown() override;
             AZStd::vector<RHI::Format> GetValidSwapChainImageFormats(const RHI::WindowHandle& windowHandle) const override;
             //////////////////////////////////////////////////////////////////////////
diff --git a/Gems/Atom/RHI/Null/Code/Source/RHI/Device.cpp b/Gems/Atom/RHI/Null/Code/Source/RHI/Device.cpp
index 08a2c4f411..b056071327 100644
--- a/Gems/Atom/RHI/Null/Code/Source/RHI/Device.cpp
+++ b/Gems/Atom/RHI/Null/Code/Source/RHI/Device.cpp
@@ -16,6 +16,11 @@ namespace AZ
             return aznew Device();
         }
 
+        Device::Device()
+        {
+            m_descriptor.m_platformLimitsDescriptor = aznew RHI::PlatformLimitsDescriptor;
+        }
+
         void Device::FillFormatsCapabilitiesInternal(FormatCapabilitiesList& formatsCapabilities)
         {
             formatsCapabilities.fill(static_cast<RHI::FormatCapabilities>(~0));
diff --git a/Gems/Atom/RHI/Null/Code/Source/RHI/Device.h b/Gems/Atom/RHI/Null/Code/Source/RHI/Device.h
index cd44135e62..27873887d4 100644
--- a/Gems/Atom/RHI/Null/Code/Source/RHI/Device.h
+++ b/Gems/Atom/RHI/Null/Code/Source/RHI/Device.h
@@ -25,12 +25,11 @@ namespace AZ
             static RHI::Ptr<Device> Create();
 
         private:
-            Device() = default;
+            Device();
             
             //////////////////////////////////////////////////////////////////////////
             // RHI::Device
-            RHI::ResultCode InitInternal([[maybe_unused]] RHI::PhysicalDevice& physicalDevice) override { return RHI::ResultCode::Success;}
-            RHI::ResultCode PostInitInternal([[maybe_unused]] const RHI::DeviceDescriptor& params) override { return RHI::ResultCode::Success;}
+            RHI::ResultCode InitInternal([[maybe_unused]] RHI::PhysicalDevice& physicalDevice) override { return RHI::ResultCode::Success; }
             void ShutdownInternal() override {}
             void CompileMemoryStatisticsInternal([[maybe_unused]] RHI::MemoryStatisticsBuilder& builder) override {}
             void UpdateCpuTimingStatisticsInternal([[maybe_unused]] RHI::CpuTimingStatistics& cpuTimingStatistics) const override {}
@@ -39,6 +38,7 @@ namespace AZ
             void WaitForIdleInternal() override {}
             AZStd::chrono::microseconds GpuTimestampToMicroseconds([[maybe_unused]] uint64_t gpuTimestamp, [[maybe_unused]] RHI::HardwareQueueClass queueClass) const override { return AZStd::chrono::microseconds();}
             void FillFormatsCapabilitiesInternal([[maybe_unused]] FormatCapabilitiesList& formatsCapabilities) override;
+            RHI::ResultCode InitializeLimits() override { return RHI::ResultCode::Success; }
             void PreShutdown() override {}
             RHI::ResourceMemoryRequirements GetResourceMemoryRequirements([[maybe_unused]] const RHI::ImageDescriptor& descriptor) override { return RHI::ResourceMemoryRequirements();}
             RHI::ResourceMemoryRequirements GetResourceMemoryRequirements([[maybe_unused]] const RHI::BufferDescriptor& descriptor) override { return RHI::ResourceMemoryRequirements();}
diff --git a/Gems/Atom/RHI/Registry/Platform/Android/PlatformLimits.setreg b/Gems/Atom/RHI/Registry/Platform/Android/PlatformLimits.setreg
new file mode 100644
index 0000000000..6ce3c88bbb
--- /dev/null
+++ b/Gems/Atom/RHI/Registry/Platform/Android/PlatformLimits.setreg
@@ -0,0 +1,27 @@
+//
+// Copyright (c) Contributors to the Open 3D Engine Project.
+// For complete copyright and license terms please see the LICENSE at the root of this distribution.
+//
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+//
+//
+//
+
+{
+    "Amazon":
+    {
+        "Atom":
+        {
+            "RHI":
+            {
+                "PlatformLimits":
+                {
+                    "metal":
+                    {
+                        "$type": "AZ::Vulkan::PlatformLimitsDescriptor"
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/Gems/Atom/RHI/Registry/Platform/Linux/PlatformLimits.setreg b/Gems/Atom/RHI/Registry/Platform/Linux/PlatformLimits.setreg
new file mode 100644
index 0000000000..7c60aeb098
--- /dev/null
+++ b/Gems/Atom/RHI/Registry/Platform/Linux/PlatformLimits.setreg
@@ -0,0 +1,27 @@
+//
+// Copyright (c) Contributors to the Open 3D Engine Project.
+// For complete copyright and license terms please see the LICENSE at the root of this distribution.
+//
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+//
+//
+//
+
+{
+    "Amazon":
+    {
+        "Atom":
+        {
+            "RHI":
+            {
+                "PlatformLimits":
+                {
+                    "vulkan":
+                    {
+                        "$type": "AZ::Vulkan::PlatformLimitsDescriptor"
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/Gems/Atom/RHI/Registry/Platform/Mac/PlatformLimits.setreg b/Gems/Atom/RHI/Registry/Platform/Mac/PlatformLimits.setreg
new file mode 100644
index 0000000000..508287b762
--- /dev/null
+++ b/Gems/Atom/RHI/Registry/Platform/Mac/PlatformLimits.setreg
@@ -0,0 +1,27 @@
+//
+// Copyright (c) Contributors to the Open 3D Engine Project.
+// For complete copyright and license terms please see the LICENSE at the root of this distribution.
+//
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+//
+//
+//
+
+{
+    "Amazon":
+    {
+        "Atom":
+        {
+            "RHI":
+            {
+                "PlatformLimits":
+                {
+                    "metal":
+                    {
+                        "$type": "AZ::Metal::PlatformLimitsDescriptor"
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/Gems/Atom/RHI/Registry/Platform/Windows/PlatformLimits.setreg b/Gems/Atom/RHI/Registry/Platform/Windows/PlatformLimits.setreg
new file mode 100644
index 0000000000..dd1273953b
--- /dev/null
+++ b/Gems/Atom/RHI/Registry/Platform/Windows/PlatformLimits.setreg
@@ -0,0 +1,38 @@
+//
+// Copyright (c) Contributors to the Open 3D Engine Project.
+// For complete copyright and license terms please see the LICENSE at the root of this distribution.
+//
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+//
+//
+//
+
+{
+    "Amazon":
+    {
+        "Atom":
+        {
+            "RHI":
+            {
+                "PlatformLimits":
+                {
+                    "dx12":
+                    {
+                        "$type": "AZ::DX12::PlatformLimitsDescriptor",
+                        "DescriptorHeapLimits":
+                        {
+                            "DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV": [1000000, 1000000],
+                            "DESCRIPTOR_HEAP_TYPE_SAMPLER": [2048, 2048],
+                            "DESCRIPTOR_HEAP_TYPE_RTV": [2048, 0],
+                            "DESCRIPTOR_HEAP_TYPE_DSV": [2048, 0]
+                        }
+                    },
+                    "vulkan":
+                    {
+                        "$type": "AZ::Vulkan::PlatformLimitsDescriptor"
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/Gems/Atom/RHI/Registry/Platform/iOS/PlatformLimits.setreg b/Gems/Atom/RHI/Registry/Platform/iOS/PlatformLimits.setreg
new file mode 100644
index 0000000000..508287b762
--- /dev/null
+++ b/Gems/Atom/RHI/Registry/Platform/iOS/PlatformLimits.setreg
@@ -0,0 +1,27 @@
+//
+// Copyright (c) Contributors to the Open 3D Engine Project.
+// For complete copyright and license terms please see the LICENSE at the root of this distribution.
+//
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+//
+//
+//
+
+{
+    "Amazon":
+    {
+        "Atom":
+        {
+            "RHI":
+            {
+                "PlatformLimits":
+                {
+                    "metal":
+                    {
+                        "$type": "AZ::Metal::PlatformLimitsDescriptor"
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/Gems/Atom/RHI/Vulkan/Code/Include/Atom/RHI.Reflect/Vulkan/PlatformLimitsDescriptor.h b/Gems/Atom/RHI/Vulkan/Code/Include/Atom/RHI.Reflect/Vulkan/PlatformLimitsDescriptor.h
index d23a51f781..5e41da9627 100644
--- a/Gems/Atom/RHI/Vulkan/Code/Include/Atom/RHI.Reflect/Vulkan/PlatformLimitsDescriptor.h
+++ b/Gems/Atom/RHI/Vulkan/Code/Include/Atom/RHI.Reflect/Vulkan/PlatformLimitsDescriptor.h
@@ -20,7 +20,7 @@ namespace AZ
     {
         struct FrameGraphExecuterData
         {
-            AZ_TYPE_INFO(FrameGraphExecuterData, "{648B4414-7208-4BFD-8E8F-CF2CA923ABCF}");
+            AZ_TYPE_INFO(AZ::Vulkan::FrameGraphExecuterData, "{648B4414-7208-4BFD-8E8F-CF2CA923ABCF}");
             static void Reflect(AZ::ReflectContext* context);
 
             //Cost per draw/dispatch item
@@ -45,8 +45,8 @@ namespace AZ
         {
             using Base = RHI::PlatformLimitsDescriptor;
         public:
-            AZ_RTTI(Vulkan::PlatformLimitsDescriptor, "{23673F3F-1562-4D1B-B130-553B35B48C64}", Base);
-            AZ_CLASS_ALLOCATOR(PlatformLimitsDescriptor, AZ::SystemAllocator, 0);
+            AZ_RTTI(AZ::Vulkan::PlatformLimitsDescriptor, "{23673F3F-1562-4D1B-B130-553B35B48C64}", Base);
+            AZ_CLASS_ALLOCATOR(AZ::Vulkan::PlatformLimitsDescriptor, AZ::SystemAllocator, 0);
             static void Reflect(AZ::ReflectContext* context);
 
             FrameGraphExecuterData m_frameGraphExecuterData;
diff --git a/Gems/Atom/RHI/Vulkan/Code/Source/RHI.Reflect/PlatformLimitsDescriptor.cpp b/Gems/Atom/RHI/Vulkan/Code/Source/RHI.Reflect/PlatformLimitsDescriptor.cpp
index d5692cb4d4..8af53c431b 100644
--- a/Gems/Atom/RHI/Vulkan/Code/Source/RHI.Reflect/PlatformLimitsDescriptor.cpp
+++ b/Gems/Atom/RHI/Vulkan/Code/Source/RHI.Reflect/PlatformLimitsDescriptor.cpp
@@ -18,8 +18,8 @@ namespace AZ
             if (SerializeContext* serializeContext = azrtti_cast<SerializeContext*>(context))
             {
                 serializeContext->Class<PlatformLimitsDescriptor, Base>()
-                    ->Version(0)
-                    ->Field("m_frameGraphExecuterData", &PlatformLimitsDescriptor::m_frameGraphExecuterData)
+                    ->Version(1)
+                    ->Field("FrameGraphExecuterData", &PlatformLimitsDescriptor::m_frameGraphExecuterData)
                     ;
             }
         }
@@ -30,11 +30,11 @@ namespace AZ
             {
                 serializeContext->Class<FrameGraphExecuterData>()
                     ->Version(0)
-                    ->Field("m_itemCost", &FrameGraphExecuterData::m_itemCost)
-                    ->Field("m_attachmentCost", &FrameGraphExecuterData::m_attachmentCost)
-                    ->Field("m_swapChainsPerCommandList", &FrameGraphExecuterData::m_swapChainsPerCommandList)
-                    ->Field("m_commandListCostThresholdMin", &FrameGraphExecuterData::m_commandListCostThresholdMin)
-                    ->Field("m_commandListsPerScopeMax", &FrameGraphExecuterData::m_commandListsPerScopeMax)
+                    ->Field("ItemCost", &FrameGraphExecuterData::m_itemCost)
+                    ->Field("AttachmentCost", &FrameGraphExecuterData::m_attachmentCost)
+                    ->Field("SwapChainsPerCommandList", &FrameGraphExecuterData::m_swapChainsPerCommandList)
+                    ->Field("CommandListCostThresholdMin", &FrameGraphExecuterData::m_commandListCostThresholdMin)
+                    ->Field("CommandListsPerScopeMax", &FrameGraphExecuterData::m_commandListsPerScopeMax)
                     ;
             }
         }
diff --git a/Gems/Atom/RHI/Vulkan/Code/Source/RHI/BufferPool.cpp b/Gems/Atom/RHI/Vulkan/Code/Source/RHI/BufferPool.cpp
index 6371b12526..12d5f9bf79 100644
--- a/Gems/Atom/RHI/Vulkan/Code/Source/RHI/BufferPool.cpp
+++ b/Gems/Atom/RHI/Vulkan/Code/Source/RHI/BufferPool.cpp
@@ -49,7 +49,7 @@ namespace AZ
         {
             auto& device = static_cast<Device&>(deviceBase);
 
-            VkDeviceSize bufferPageSizeInBytes = RHI::RHISystemInterface::Get()->GetPlatformLimitsDescriptor()->m_platformDefaultValues.m_bufferPoolPageSizeInBytes;
+            VkDeviceSize bufferPageSizeInBytes = device.GetDescriptor().m_platformLimitsDescriptor->m_platformDefaultValues.m_bufferPoolPageSizeInBytes;
             VkMemoryPropertyFlags additionalMemoryPropertyFlags = 0;
             if (const auto* descriptor = azrtti_cast<const BufferPoolDescriptor*>(&descriptorBase))
             {
diff --git a/Gems/Atom/RHI/Vulkan/Code/Source/RHI/Device.cpp b/Gems/Atom/RHI/Vulkan/Code/Source/RHI/Device.cpp
index 05ff8bb2a6..d6cf28e78f 100644
--- a/Gems/Atom/RHI/Vulkan/Code/Source/RHI/Device.cpp
+++ b/Gems/Atom/RHI/Vulkan/Code/Source/RHI/Device.cpp
@@ -7,6 +7,8 @@
  */
 
 #include <Atom/RHI.Loader/FunctionLoader.h>
+#include <Atom/RHI.Reflect/Vulkan/PlatformLimitsDescriptor.h>
+#include <Atom/RHI/Factory.h>
 #include <Atom/RHI/RHISystemInterface.h>
 #include <Atom/RHI/TransientAttachmentPool.h>
 #include <AzCore/std/containers/set.h>
@@ -31,6 +33,13 @@ namespace AZ
 {
     namespace Vulkan
     {
+        Device::Device()
+        {
+            RHI::Ptr<PlatformLimitsDescriptor> platformLimitsDescriptor = aznew PlatformLimitsDescriptor();
+            platformLimitsDescriptor->LoadPlatformLimitsDescriptor(RHI::Factory::Get().GetName().GetCStr());
+            m_descriptor.m_platformLimitsDescriptor = RHI::Ptr<RHI::PlatformLimitsDescriptor>(platformLimitsDescriptor);
+        }
+
         RHI::Ptr<Device> Device::Create()
         {
             return aznew Device();
@@ -232,7 +241,7 @@ namespace AZ
             return RHI::ResultCode::Success;
         }
 
-        RHI::ResultCode Device::PostInitInternal( const RHI::DeviceDescriptor& descriptor)
+        RHI::ResultCode Device::InitializeLimits()
         {
             CommandQueueContext::Descriptor commandQueueContextDescriptor;
             commandQueueContextDescriptor.m_frameCountMax = RHI::Limits::Device::FrameCountMax;
@@ -241,7 +250,7 @@ namespace AZ
 
             // Initialize member variables.
             ReleaseQueue::Descriptor releaseQueueDescriptor;
-            releaseQueueDescriptor.m_collectLatency = descriptor.m_frameCountMax - 1;
+            releaseQueueDescriptor.m_collectLatency = m_descriptor.m_frameCountMax - 1;
             m_releaseQueue.Init(releaseQueueDescriptor);
             
 
@@ -272,7 +281,7 @@ namespace AZ
             poolDesc.m_heapMemoryLevel = RHI::HeapMemoryLevel::Host;
             poolDesc.m_hostMemoryAccess = RHI::HostMemoryAccess::Write;
             poolDesc.m_bindFlags = RHI::BufferBindFlags::CopyRead;
-            poolDesc.m_budgetInBytes = RHI::RHISystemInterface::Get()->GetPlatformLimitsDescriptor()->m_platformDefaultValues.m_stagingBufferBudgetInBytes;
+            poolDesc.m_budgetInBytes = m_descriptor.m_platformLimitsDescriptor->m_platformDefaultValues.m_stagingBufferBudgetInBytes;
             result = m_stagingBufferPool->Init(*this, poolDesc);
             RETURN_RESULT_IF_UNSUCCESSFUL(result);
 
diff --git a/Gems/Atom/RHI/Vulkan/Code/Source/RHI/Device.h b/Gems/Atom/RHI/Vulkan/Code/Source/RHI/Device.h
index 28e56d1fa9..5a8ed04c11 100644
--- a/Gems/Atom/RHI/Vulkan/Code/Source/RHI/Device.h
+++ b/Gems/Atom/RHI/Vulkan/Code/Source/RHI/Device.h
@@ -110,7 +110,7 @@ namespace AZ
             void DestroyBufferResource(VkBuffer vkBuffer) const;
 
         private:
-            Device() = default;
+            Device();
 
             //////////////////////////////////////////////////////////////////////////
             // RHI::Object
@@ -120,7 +120,6 @@ namespace AZ
             //////////////////////////////////////////////////////////////////////////
             // RHI::Device
             RHI::ResultCode InitInternal(RHI::PhysicalDevice& physicalDevice) override;
-            RHI::ResultCode PostInitInternal(const RHI::DeviceDescriptor& params) override;
 
             void ShutdownInternal() override;
             void BeginFrameInternal() override;
@@ -131,6 +130,7 @@ namespace AZ
             AZStd::vector<RHI::Format> GetValidSwapChainImageFormats(const RHI::WindowHandle& windowHandle) const override;
             AZStd::chrono::microseconds GpuTimestampToMicroseconds(uint64_t gpuTimestamp, RHI::HardwareQueueClass queueClass) const override;
             void FillFormatsCapabilitiesInternal(FormatCapabilitiesList& formatsCapabilities) override;
+            RHI::ResultCode InitializeLimits() override;
             void PreShutdown() override;
             RHI::ResourceMemoryRequirements GetResourceMemoryRequirements(const RHI::ImageDescriptor& descriptor) override;
             RHI::ResourceMemoryRequirements GetResourceMemoryRequirements(const RHI::BufferDescriptor& descriptor) override;
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Public/RPISystem.cpp b/Gems/Atom/RPI/Code/Source/RPI.Public/RPISystem.cpp
index efc050eb68..5eb9bd2d46 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Public/RPISystem.cpp
+++ b/Gems/Atom/RPI/Code/Source/RPI.Public/RPISystem.cpp
@@ -349,19 +349,6 @@ namespace AZ
                 return;
             }
 
-            //[GFX TODO][ATOM-5867] - Move file loading code within RHI to reduce coupling with RPI
-            AZStd::string platformLimitsFilePath = AZStd::string::format("config/platform/%s/%s/platformlimits.azasset", AZ_TRAIT_OS_PLATFORM_NAME, GetRenderApiName().GetCStr());
-            AZStd::to_lower(platformLimitsFilePath.begin(), platformLimitsFilePath.end());
-            
-            Data::Asset<AnyAsset> platformLimitsAsset;
-            platformLimitsAsset = RPI::AssetUtils::LoadCriticalAsset<AnyAsset>(platformLimitsFilePath.c_str(), RPI::AssetUtils::TraceLevel::None);
-            // Only read the m_platformLimits if the platformLimitsAsset is ready.
-            // The platformLimitsAsset may not exist for null renderer which is allowed
-            if (platformLimitsAsset.IsReady())
-            {
-                m_descriptor.m_rhiSystemDescriptor.m_platformLimits = RPI::GetDataFromAnyAsset<RHI::PlatformLimits>(platformLimitsAsset);
-            }
-
             m_commonShaderAssetForSrgs = AssetUtils::LoadCriticalAsset<ShaderAsset>( m_descriptor.m_commonSrgsShaderAssetPath.c_str());
             if (!m_commonShaderAssetForSrgs.IsReady())
             {
diff --git a/Gems/Atom/RPI/Code/Tests/Common/RHI/Factory.cpp b/Gems/Atom/RPI/Code/Tests/Common/RHI/Factory.cpp
index 115ccb3819..62af2852e6 100644
--- a/Gems/Atom/RPI/Code/Tests/Common/RHI/Factory.cpp
+++ b/Gems/Atom/RPI/Code/Tests/Common/RHI/Factory.cpp
@@ -47,7 +47,6 @@ namespace UnitTest
 
             RHI::Ptr<RHI::Device> device = Get().CreateDevice();
             device->Init(*physicalDevices[0]);
-            device->PostInit(RHI::DeviceDescriptor{});
 
             return device;
         }
diff --git a/Gems/Atom/RPI/Code/Tests/Common/RHI/Stubs.cpp b/Gems/Atom/RPI/Code/Tests/Common/RHI/Stubs.cpp
index 3d40aa27cf..a8d2ac2b0b 100644
--- a/Gems/Atom/RPI/Code/Tests/Common/RHI/Stubs.cpp
+++ b/Gems/Atom/RPI/Code/Tests/Common/RHI/Stubs.cpp
@@ -20,6 +20,11 @@ namespace UnitTest
             m_descriptor.m_description = "UnitTest Fake Device";
         }
 
+        Device::Device()
+        {
+            m_descriptor.m_platformLimitsDescriptor = aznew RHI::PlatformLimitsDescriptor;
+        }
+
         RHI::PhysicalDeviceList PhysicalDevice::Enumerate()
         {
             return RHI::PhysicalDeviceList{ aznew PhysicalDevice };
diff --git a/Gems/Atom/RPI/Code/Tests/Common/RHI/Stubs.h b/Gems/Atom/RPI/Code/Tests/Common/RHI/Stubs.h
index be362c60d6..c3768c1ce6 100644
--- a/Gems/Atom/RPI/Code/Tests/Common/RHI/Stubs.h
+++ b/Gems/Atom/RPI/Code/Tests/Common/RHI/Stubs.h
@@ -52,10 +52,10 @@ namespace UnitTest
         {
         public:
             AZ_CLASS_ALLOCATOR(Device, AZ::SystemAllocator, 0);
+            Device();
 
         private:
             AZ::RHI::ResultCode InitInternal(AZ::RHI::PhysicalDevice&) override { return AZ::RHI::ResultCode::Success; }
-            AZ::RHI::ResultCode PostInitInternal(const AZ::RHI::DeviceDescriptor&) override { return AZ::RHI::ResultCode::Success; }
             void ShutdownInternal() override {}
             void BeginFrameInternal() override {}
             void EndFrameInternal() override {}
@@ -67,6 +67,7 @@ namespace UnitTest
                 return AZStd::chrono::microseconds();
             }
             void FillFormatsCapabilitiesInternal([[maybe_unused]] FormatCapabilitiesList& formatsCapabilities) override {}
+            AZ::RHI::ResultCode InitializeLimits() override { return AZ::RHI::ResultCode::Success; }
             void PreShutdown() override {}
             AZ::RHI::ResourceMemoryRequirements GetResourceMemoryRequirements([[maybe_unused]] const AZ::RHI::ImageDescriptor& descriptor) { return AZ::RHI::ResourceMemoryRequirements{}; };
             AZ::RHI::ResourceMemoryRequirements GetResourceMemoryRequirements([[maybe_unused]] const AZ::RHI::BufferDescriptor& descriptor) { return AZ::RHI::ResourceMemoryRequirements{}; };