Initial commit

Gems/SurfaceData/Code/Source/Components/SurfaceDataColliderComponent.cpp

@@ -0,0 +1,380 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensor's.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include "SurfaceData_precompiled.h"
+#include "SurfaceDataColliderComponent.h"
+
+#include <AzCore/Debug/Profiler.h>
+#include <AzCore/RTTI/BehaviorContext.h>
+#include <AzCore/Serialization/EditContext.h>
+#include <AzCore/Serialization/SerializeContext.h>
+#include <AzCore/Math/IntersectSegment.h>
+
+#include <AzFramework/Physics/Casts.h>
+#include <AzFramework/Physics/World.h>
+#include <AzFramework/Physics/WorldBodyBus.h>
+
+#include <SurfaceData/SurfaceDataSystemRequestBus.h>
+#include <SurfaceData/Utility/SurfaceDataUtility.h>
+
+
+namespace SurfaceData
+{
+    void SurfaceDataColliderConfig::Reflect(AZ::ReflectContext* context)
+    {
+        if (auto serialize = azrtti_cast<AZ::SerializeContext*>(context))
+        {
+            serialize->Class<SurfaceDataColliderConfig, AZ::ComponentConfig>()
+                ->Version(0)
+                ->Field("ProviderTags", &SurfaceDataColliderConfig::m_providerTags)
+                ->Field("ModifierTags", &SurfaceDataColliderConfig::m_modifierTags)
+                ;
+
+            if (auto edit = serialize->GetEditContext())
+            {
+                edit->Class<SurfaceDataColliderConfig>(
+                    "PhysX Collider Surface Tag Emitter", "")
+                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                    ->Attribute(AZ::Edit::Attributes::Visibility, AZ::Edit::PropertyVisibility::ShowChildrenOnly)
+                    ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
+                    ->DataElement(0, &SurfaceDataColliderConfig::m_providerTags, "Generated Tags", "Surface tags to add to created points")
+                    ->DataElement(0, &SurfaceDataColliderConfig::m_modifierTags, "Extended Tags", "Surface tags to add to contained points")
+                    ;
+            }
+        }
+
+        if (auto behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
+        {
+            behaviorContext->Class<SurfaceDataColliderConfig>()
+                ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::Preview)
+                ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
+                ->Attribute(AZ::Script::Attributes::Category, "Vegetation")
+                ->Attribute(AZ::Script::Attributes::Module, "surface_data")
+                ->Constructor()
+                ->Property("providerTags", BehaviorValueProperty(&SurfaceDataColliderConfig::m_providerTags))
+                ->Property("modifierTags", BehaviorValueProperty(&SurfaceDataColliderConfig::m_modifierTags))
+                ;
+        }
+    }
+
+    void SurfaceDataColliderComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& services)
+    {
+        services.push_back(AZ_CRC("SurfaceDataProviderService", 0xfe9fb95e));
+        services.push_back(AZ_CRC("SurfaceDataModifierService", 0x68f8aa72));
+    }
+
+    void SurfaceDataColliderComponent::GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& services)
+    {
+        services.push_back(AZ_CRC("SurfaceDataProviderService", 0xfe9fb95e));
+        services.push_back(AZ_CRC("SurfaceDataModifierService", 0x68f8aa72));
+    }
+
+    void SurfaceDataColliderComponent::GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& services)
+    {
+        services.push_back(AZ_CRC("PhysXColliderService", 0x4ff43f7c));
+    }
+
+    void SurfaceDataColliderComponent::GetDependentServices(AZ::ComponentDescriptor::DependencyArrayType& services)
+    {
+        services.push_back(AZ_CRC("PhysicsWorldBodyService", 0x944da0cc));
+    }
+
+    void SurfaceDataColliderComponent::Reflect(AZ::ReflectContext* context)
+    {
+        SurfaceDataColliderConfig::Reflect(context);
+
+        if (auto serialize = azrtti_cast<AZ::SerializeContext*>(context))
+        {
+            serialize->Class<SurfaceDataColliderComponent, AZ::Component>()
+                ->Version(0)
+                ->Field("Configuration", &SurfaceDataColliderComponent::m_configuration)
+                ;
+        }
+        if (auto behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
+        {
+            behaviorContext->Class<SurfaceDataColliderComponent>()
+                ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::Preview)
+                ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
+                ->Attribute(AZ::Script::Attributes::Category, "Vegetation")
+                ->Attribute(AZ::Script::Attributes::Module, "surface_data")
+                ->Constructor()
+                ->Property("providerTags",
+                    [](SurfaceDataColliderComponent* component) { return component->m_configuration.m_providerTags; },
+                    [](SurfaceDataColliderComponent* component, SurfaceData::SurfaceTagVector value)
+                       {
+                            component->m_configuration.m_providerTags = value;
+                            component->OnCompositionChanged();
+                       })
+                ->Property("modifierTags",
+                    [](SurfaceDataColliderComponent* component) { return component->m_configuration.m_modifierTags; },
+                    [](SurfaceDataColliderComponent* component, SurfaceData::SurfaceTagVector value)
+                       {
+                           component->m_configuration.m_modifierTags = value;
+                           component->OnCompositionChanged();
+                       })
+                ;
+        }
+    }
+
+    SurfaceDataColliderComponent::SurfaceDataColliderComponent(const SurfaceDataColliderConfig& configuration)
+        : m_configuration(configuration)
+    {
+    }
+
+    void SurfaceDataColliderComponent::Activate()
+    {
+        m_providerHandle = InvalidSurfaceDataRegistryHandle;
+        m_modifierHandle = InvalidSurfaceDataRegistryHandle;
+        m_refresh = false;
+
+        AZ::TransformNotificationBus::Handler::BusConnect(GetEntityId());
+        Physics::ColliderComponentEventBus::Handler::BusConnect(GetEntityId());
+
+        // Update the cached collider data and bounds, then register the surface data provider / modifier
+        UpdateColliderData();
+    }
+
+    void SurfaceDataColliderComponent::Deactivate()
+    {
+        if (m_providerHandle != InvalidSurfaceDataRegistryHandle)
+        {
+            SurfaceDataSystemRequestBus::Broadcast(&SurfaceDataSystemRequestBus::Events::UnregisterSurfaceDataProvider, m_providerHandle);
+            m_providerHandle = InvalidSurfaceDataRegistryHandle;
+        }
+        if (m_modifierHandle != InvalidSurfaceDataRegistryHandle)
+        {
+            SurfaceDataSystemRequestBus::Broadcast(&SurfaceDataSystemRequestBus::Events::UnregisterSurfaceDataModifier, m_modifierHandle);
+            m_modifierHandle = InvalidSurfaceDataRegistryHandle;
+        }
+
+        AZ::TickBus::Handler::BusDisconnect();
+        AZ::TransformNotificationBus::Handler::BusDisconnect();
+        Physics::ColliderComponentEventBus::Handler::BusDisconnect();
+        SurfaceDataProviderRequestBus::Handler::BusDisconnect();
+        SurfaceDataModifierRequestBus::Handler::BusDisconnect();
+        m_refresh = false;
+
+        // Clear the cached mesh data
+        {
+            AZStd::lock_guard<decltype(m_cacheMutex)> lock(m_cacheMutex);
+            m_colliderBounds = AZ::Aabb::CreateNull();
+        }
+    }
+
+    bool SurfaceDataColliderComponent::ReadInConfig(const AZ::ComponentConfig* baseConfig)
+    {
+        if (auto config = azrtti_cast<const SurfaceDataColliderConfig*>(baseConfig))
+        {
+            m_configuration = *config;
+            return true;
+        }
+        return false;
+    }
+
+    bool SurfaceDataColliderComponent::WriteOutConfig(AZ::ComponentConfig* outBaseConfig) const
+    {
+        if (auto config = azrtti_cast<SurfaceDataColliderConfig*>(outBaseConfig))
+        {
+            *config = m_configuration;
+            return true;
+        }
+        return false;
+    }
+
+    bool SurfaceDataColliderComponent::DoRayTrace(const AZ::Vector3& inPosition, bool queryPointOnly, AZ::Vector3& outPosition, AZ::Vector3& outNormal) const
+    {
+        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+
+        AZStd::lock_guard<decltype(m_cacheMutex)> lock(m_cacheMutex);
+
+        // test AABB as first pass to claim the point
+        const AZ::Vector3 testPosition = AZ::Vector3(
+            inPosition.GetX(),
+            inPosition.GetY(),
+            m_colliderBounds.GetCenter().GetZ());
+
+        if (!m_colliderBounds.Contains(testPosition))
+        {
+            return false;
+        }
+
+        Physics::RayCastRequest request;
+        request.m_direction = AZ::Vector3(0.0f, 0.0f, -1.0f);
+        if (queryPointOnly)
+        {
+            // We're checking to see if the point is *inside* the collider, so give it a distance of 0.
+            request.m_start = inPosition;
+            request.m_distance = 0.0f;
+        }
+        else
+        {
+            // We're casting the ray to look for a collision, so start at the top of the collider and cast downwards
+            // the full height of the collider.
+            request.m_start = AZ::Vector3(inPosition.GetX(), inPosition.GetY(), m_colliderBounds.GetMax().GetZ());
+            request.m_distance = m_colliderBounds.GetExtents().GetZ();
+        }
+
+        Physics::RayCastHit result;
+        Physics::WorldBodyRequestBus::EventResult(result, GetEntityId(), &Physics::WorldBodyRequestBus::Events::RayCast, request);
+
+        if (result)
+        {
+            outPosition = result.m_position;
+            outNormal = result.m_normal;
+            return true;
+        }
+
+        return false;
+    }
+
+    void SurfaceDataColliderComponent::GetSurfacePoints(const AZ::Vector3& inPosition, SurfacePointList& surfacePointList) const
+    {
+        AZ::Vector3 hitPosition;
+        AZ::Vector3 hitNormal;
+
+        // We want a full raycast, so don't just query the start point.
+        constexpr bool queryPointOnly = false;
+
+        if (DoRayTrace(inPosition, queryPointOnly, hitPosition, hitNormal))
+        {
+            SurfacePoint point;
+            point.m_entityId = GetEntityId();
+            point.m_position = hitPosition;
+            point.m_normal = hitNormal;
+            AddMaxValueForMasks(point.m_masks, m_configuration.m_providerTags, 1.0f);
+            surfacePointList.push_back(point);
+        }
+    }
+
+    void SurfaceDataColliderComponent::ModifySurfacePoints(SurfacePointList& surfacePointList) const
+    {
+        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+
+        AZStd::lock_guard<decltype(m_cacheMutex)> lock(m_cacheMutex);
+
+        if (m_colliderBounds.IsValid() && !m_configuration.m_modifierTags.empty())
+        {
+            const AZ::EntityId entityId = GetEntityId();
+            for (auto& point : surfacePointList)
+            {
+                if (point.m_entityId != entityId && m_colliderBounds.Contains(point.m_position))
+                {
+                    AZ::Vector3 hitPosition;
+                    AZ::Vector3 hitNormal;
+                    constexpr bool queryPointOnly = true;
+                    if (DoRayTrace(point.m_position, queryPointOnly, hitPosition, hitNormal))
+                    {
+                        AddMaxValueForMasks(point.m_masks, m_configuration.m_modifierTags, 1.0f);
+                    }
+                }
+            }
+        }
+    }
+
+    void SurfaceDataColliderComponent::OnCompositionChanged()
+    {
+        if (!m_refresh)
+        {
+            m_refresh = true;
+            AZ::TickBus::Handler::BusConnect();
+        }
+    }
+
+    void SurfaceDataColliderComponent::OnColliderChanged()
+    {
+        OnCompositionChanged();
+    }
+
+    void SurfaceDataColliderComponent::OnTransformChanged([[maybe_unused]] const AZ::Transform& local, [[maybe_unused]] const AZ::Transform& world)
+    {
+        OnCompositionChanged();
+    }
+
+    void SurfaceDataColliderComponent::OnTick([[maybe_unused]] float deltaTime, [[maybe_unused]] AZ::ScriptTimePoint time)
+    {
+        if (m_refresh)
+        {
+            UpdateColliderData();
+            m_refresh = false;
+        }
+        AZ::TickBus::Handler::BusDisconnect();
+    }
+
+    void SurfaceDataColliderComponent::UpdateColliderData()
+    {
+        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+
+        bool colliderValidBeforeUpdate = false;
+        bool colliderValidAfterUpdate = false;
+
+        {
+            AZStd::lock_guard<decltype(m_cacheMutex)> lock(m_cacheMutex);
+
+            colliderValidBeforeUpdate = m_colliderBounds.IsValid();
+
+            m_colliderBounds = AZ::Aabb::CreateNull();
+            Physics::WorldBodyRequestBus::EventResult(m_colliderBounds, GetEntityId(), &Physics::WorldBodyRequestBus::Events::GetAabb);
+
+            colliderValidAfterUpdate = m_colliderBounds.IsValid();
+        }
+
+        SurfaceDataRegistryEntry providerRegistryEntry;
+        providerRegistryEntry.m_entityId = GetEntityId();
+        providerRegistryEntry.m_bounds = m_colliderBounds;
+        providerRegistryEntry.m_tags = m_configuration.m_providerTags;
+
+        SurfaceDataRegistryEntry modifierRegistryEntry(providerRegistryEntry);
+        modifierRegistryEntry.m_tags = m_configuration.m_modifierTags;
+
+
+        if (!colliderValidBeforeUpdate && !colliderValidAfterUpdate)
+        {
+            // We didn't have a valid collider before or after running this, so do nothing.
+        }
+        else if (!colliderValidBeforeUpdate && colliderValidAfterUpdate)
+        {
+            // Our collider has become valid, so register as a provider and save off the provider handle
+            AZ_Assert((m_providerHandle == InvalidSurfaceDataRegistryHandle), "Surface data handle is initialized before our collider became valid");
+            AZ_Assert((m_modifierHandle == InvalidSurfaceDataRegistryHandle), "Surface Modifier data handle is initialized before our collider became valid");
+            AZ_Assert(m_colliderBounds.IsValid(), "Collider Geometry isn't correctly initialized.");
+            SurfaceDataSystemRequestBus::BroadcastResult(m_providerHandle, &SurfaceDataSystemRequestBus::Events::RegisterSurfaceDataProvider, providerRegistryEntry);
+            SurfaceDataSystemRequestBus::BroadcastResult(m_modifierHandle, &SurfaceDataSystemRequestBus::Events::RegisterSurfaceDataModifier, modifierRegistryEntry);
+
+            // Start listening for surface data events
+            AZ_Assert((m_providerHandle != InvalidSurfaceDataRegistryHandle), "Invalid surface data handle");
+            AZ_Assert((m_modifierHandle != InvalidSurfaceDataRegistryHandle), "Invalid surface data handle");
+            SurfaceDataProviderRequestBus::Handler::BusConnect(m_providerHandle);
+            SurfaceDataModifierRequestBus::Handler::BusConnect(m_modifierHandle);
+        }
+        else if (colliderValidBeforeUpdate && !colliderValidAfterUpdate)
+        {
+            // Our collider has stopped being valid, so unregister and stop listening for surface data events
+            AZ_Assert((m_providerHandle != InvalidSurfaceDataRegistryHandle), "Invalid surface data handle");
+            AZ_Assert((m_modifierHandle != InvalidSurfaceDataRegistryHandle), "Invalid surface data handle");
+            SurfaceDataSystemRequestBus::Broadcast(&SurfaceDataSystemRequestBus::Events::UnregisterSurfaceDataProvider, m_providerHandle);
+            SurfaceDataSystemRequestBus::Broadcast(&SurfaceDataSystemRequestBus::Events::UnregisterSurfaceDataModifier, m_modifierHandle);
+            m_providerHandle = InvalidSurfaceDataRegistryHandle;
+            m_modifierHandle = InvalidSurfaceDataRegistryHandle;
+
+            SurfaceDataProviderRequestBus::Handler::BusDisconnect();
+            SurfaceDataModifierRequestBus::Handler::BusDisconnect();
+        }
+        else if (colliderValidBeforeUpdate && colliderValidAfterUpdate)
+        {
+            // Our collider was valid before and after, it just changed in some way, so update our registry entry.
+            AZ_Assert((m_providerHandle != InvalidSurfaceDataRegistryHandle), "Invalid surface data handle");
+            AZ_Assert((m_modifierHandle != InvalidSurfaceDataRegistryHandle), "Invalid modifier data handle");
+            SurfaceDataSystemRequestBus::Broadcast(&SurfaceDataSystemRequestBus::Events::UpdateSurfaceDataProvider, m_providerHandle, providerRegistryEntry);
+            SurfaceDataSystemRequestBus::Broadcast(&SurfaceDataSystemRequestBus::Events::UpdateSurfaceDataModifier, m_modifierHandle, modifierRegistryEntry);
+        }
+    }
+}

Gems/SurfaceData/Code/Source/Components/SurfaceDataColliderComponent.h

@@ -0,0 +1,108 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <AzCore/Asset/AssetCommon.h>
+#include <AzCore/Component/Component.h>
+#include <AzCore/Component/TickBus.h>
+#include <AzCore/Component/TransformBus.h>
+#include <AzFramework/Physics/ColliderComponentBus.h>
+
+#include <SurfaceData/SurfaceDataTypes.h>
+#include <SurfaceData/SurfaceDataProviderRequestBus.h>
+#include <SurfaceData/SurfaceDataModifierRequestBus.h>
+
+namespace LmbrCentral
+{
+    template<typename, typename>
+    class EditorWrappedComponentBase;
+}
+
+namespace SurfaceData
+{
+    class SurfaceDataColliderConfig
+        : public AZ::ComponentConfig
+    {
+    public:
+        AZ_CLASS_ALLOCATOR(SurfaceDataColliderConfig, AZ::SystemAllocator, 0);
+        AZ_RTTI(SurfaceDataColliderConfig, "{D435DDB9-C513-4A2E-B0AC-9933E9360857}", AZ::ComponentConfig);
+        static void Reflect(AZ::ReflectContext* context);
+        SurfaceTagVector m_providerTags;
+        SurfaceTagVector m_modifierTags;
+    };
+
+    class SurfaceDataColliderComponent
+        : public AZ::Component
+        , public AZ::TickBus::Handler
+        , public AZ::TransformNotificationBus::Handler
+        , public SurfaceDataProviderRequestBus::Handler
+        , private SurfaceDataModifierRequestBus::Handler
+        , public Physics::ColliderComponentEventBus::Handler
+    {
+    public:
+        template<typename, typename> friend class LmbrCentral::EditorWrappedComponentBase;
+        AZ_COMPONENT(SurfaceDataColliderComponent, "{8BECC930-9B2A-442D-A291-8A3F6B6D1071}");
+        static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& services);
+        static void GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& services);
+        static void GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& services);
+        static void GetDependentServices(AZ::ComponentDescriptor::DependencyArrayType& services);
+        static void Reflect(AZ::ReflectContext* context);
+
+        SurfaceDataColliderComponent(const SurfaceDataColliderConfig& configuration);
+        SurfaceDataColliderComponent() = default;
+        ~SurfaceDataColliderComponent() = default;
+
+        //////////////////////////////////////////////////////////////////////////
+        // AZ::Component interface implementation
+        void Activate() override;
+        void Deactivate() override;
+        bool ReadInConfig(const AZ::ComponentConfig* baseConfig) override;
+        bool WriteOutConfig(AZ::ComponentConfig* outBaseConfig) const override;
+
+        //////////////////////////////////////////////////////////////////////////
+        // ColliderComponentEventBus
+        // For physics meshes only
+        void OnColliderChanged() override;
+
+        //////////////////////////////////////////////////////////////////////////
+        // TransformNotificationBus
+        void OnTransformChanged(const AZ::Transform& local, const AZ::Transform& world) override;
+
+        ////////////////////////////////////////////////////////////////////////
+        // AZ::TickBus
+        void OnTick(float deltaTime, AZ::ScriptTimePoint time) override;
+
+        ////////////////////////////////////////////////////////////////////////
+        // SurfaceDataProviderRequestBus
+        void GetSurfacePoints(const AZ::Vector3& inPosition, SurfacePointList& surfacePointList) const override;
+
+        //////////////////////////////////////////////////////////////////////////
+        // SurfaceDataModifierRequestBus
+        void ModifySurfacePoints(SurfacePointList& surfacePointList) const override;
+
+    private:
+        bool DoRayTrace(const AZ::Vector3& inPosition, bool queryPointOnly, AZ::Vector3& outPosition, AZ::Vector3& outNormal) const;
+        void UpdateColliderData();
+        void OnCompositionChanged();
+
+        SurfaceDataColliderConfig m_configuration;
+
+        SurfaceDataRegistryHandle m_providerHandle = InvalidSurfaceDataRegistryHandle;
+        SurfaceDataRegistryHandle m_modifierHandle = InvalidSurfaceDataRegistryHandle;
+
+        // cached data
+        AZStd::atomic_bool m_refresh{ false };
+        mutable AZStd::recursive_mutex m_cacheMutex;
+        AZ::Aabb m_colliderBounds = AZ::Aabb::CreateNull();
+    };
+}

Gems/SurfaceData/Code/Source/Components/SurfaceDataMeshComponent.cpp

@@ -0,0 +1,303 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensor's.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include "SurfaceData_precompiled.h"
+#include "SurfaceDataMeshComponent.h"
+
+#include <AzCore/Debug/Profiler.h>
+#include <AzCore/Serialization/EditContext.h>
+#include <AzCore/Serialization/SerializeContext.h>
+#include <LmbrCentral/Rendering/MeshAsset.h>
+
+#include <SurfaceData/SurfaceDataSystemRequestBus.h>
+#include <SurfaceData/Utility/SurfaceDataUtility.h>
+
+#include <Cry_Matrix34.h>
+#include <Cry_GeoIntersect.h>
+#include <Cry_Geo.h>
+#include <IStatObj.h>
+#include <MathConversion.h>
+
+namespace SurfaceData
+{
+    void SurfaceDataMeshConfig::Reflect(AZ::ReflectContext* context)
+    {
+        AZ::SerializeContext* serialize = azrtti_cast<AZ::SerializeContext*>(context);
+        if (serialize)
+        {
+            serialize->Class<SurfaceDataMeshConfig, AZ::ComponentConfig>()
+                ->Version(0)
+                ->Field("SurfaceTags", &SurfaceDataMeshConfig::m_tags)
+                ;
+
+            AZ::EditContext* edit = serialize->GetEditContext();
+            if (edit)
+            {
+                edit->Class<SurfaceDataMeshConfig>(
+                    "Mesh Surface Tag Emitter", "")
+                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                    ->Attribute(AZ::Edit::Attributes::Visibility, AZ::Edit::PropertyVisibility::ShowChildrenOnly)
+                    ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
+                    ->DataElement(0, &SurfaceDataMeshConfig::m_tags, "Generated Tags", "")
+                    ;
+            }
+        }
+    }
+
+    void SurfaceDataMeshComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& services)
+    {
+        services.push_back(AZ_CRC("SurfaceDataProviderService", 0xfe9fb95e));
+    }
+
+    void SurfaceDataMeshComponent::GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& services)
+    {
+        services.push_back(AZ_CRC("SurfaceDataProviderService", 0xfe9fb95e));
+    }
+
+    void SurfaceDataMeshComponent::GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& services)
+    {
+        services.push_back(AZ_CRC("MeshService", 0x71d8a455));
+    }
+
+    void SurfaceDataMeshComponent::Reflect(AZ::ReflectContext* context)
+    {
+        SurfaceDataMeshConfig::Reflect(context);
+
+        AZ::SerializeContext* serialize = azrtti_cast<AZ::SerializeContext*>(context);
+        if (serialize)
+        {
+            serialize->Class<SurfaceDataMeshComponent, AZ::Component>()
+                ->Version(0)
+                ->Field("Configuration", &SurfaceDataMeshComponent::m_configuration)
+                ;
+        }
+    }
+
+    SurfaceDataMeshComponent::SurfaceDataMeshComponent(const SurfaceDataMeshConfig& configuration)
+        : m_configuration(configuration)
+    {
+    }
+
+    void SurfaceDataMeshComponent::Activate()
+    {
+        AZ::TransformNotificationBus::Handler::BusConnect(GetEntityId());
+        LmbrCentral::MeshComponentNotificationBus::Handler::BusConnect(GetEntityId());
+
+        m_providerHandle = InvalidSurfaceDataRegistryHandle;
+        m_refresh = false;
+
+        // Update the cached mesh data and bounds, then register the surface data provider
+        UpdateMeshData();
+    }
+
+    void SurfaceDataMeshComponent::Deactivate()
+    {
+        if (m_providerHandle != InvalidSurfaceDataRegistryHandle)
+        {
+            SurfaceDataSystemRequestBus::Broadcast(&SurfaceDataSystemRequestBus::Events::UnregisterSurfaceDataProvider, m_providerHandle);
+            m_providerHandle = InvalidSurfaceDataRegistryHandle;
+        }
+
+        SurfaceDataProviderRequestBus::Handler::BusDisconnect();
+        AZ::TickBus::Handler::BusDisconnect();
+        AZ::TransformNotificationBus::Handler::BusDisconnect();
+        LmbrCentral::MeshComponentNotificationBus::Handler::BusDisconnect();
+        m_refresh = false;
+
+        // Clear the cached mesh data
+        {
+            AZStd::lock_guard<decltype(m_cacheMutex)> lock(m_cacheMutex);
+            m_meshAssetData = {};
+            m_meshBounds = AZ::Aabb::CreateNull();
+            m_meshWorldTM = AZ::Transform::CreateIdentity();
+            m_meshWorldTMInverse = AZ::Transform::CreateIdentity();
+        }
+    }
+
+    bool SurfaceDataMeshComponent::ReadInConfig(const AZ::ComponentConfig* baseConfig)
+    {
+        if (auto config = azrtti_cast<const SurfaceDataMeshConfig*>(baseConfig))
+        {
+            m_configuration = *config;
+            return true;
+        }
+        return false;
+    }
+
+    bool SurfaceDataMeshComponent::WriteOutConfig(AZ::ComponentConfig* outBaseConfig) const
+    {
+        if (auto config = azrtti_cast<SurfaceDataMeshConfig*>(outBaseConfig))
+        {
+            *config = m_configuration;
+            return true;
+        }
+        return false;
+    }
+
+    bool SurfaceDataMeshComponent::DoRayTrace(const AZ::Vector3& inPosition, AZ::Vector3& outPosition, AZ::Vector3& outNormal) const
+    {
+        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+
+        AZStd::lock_guard<decltype(m_cacheMutex)> lock(m_cacheMutex);
+
+        // test AABB as first pass to claim the point
+        const AZ::Vector3 testPosition = AZ::Vector3(
+            inPosition.GetX(),
+            inPosition.GetY(),
+            (m_meshBounds.GetMax().GetZ() + m_meshBounds.GetMin().GetZ()) * 0.5f);
+
+        if (!m_meshBounds.Contains(testPosition))
+        {
+            return false;
+        }
+
+        LmbrCentral::MeshAsset* mesh = m_meshAssetData.GetAs<LmbrCentral::MeshAsset>();
+        if (!mesh)
+        {
+            return false;
+        }
+
+        const AZ::Vector3 rayOrigin = AZ::Vector3(inPosition.GetX(), inPosition.GetY(), m_meshBounds.GetMax().GetZ() + s_rayAABBHeightPadding);
+        const AZ::Vector3 rayDirection = -AZ::Vector3::CreateAxisZ();
+        return GetMeshRayIntersection(*mesh, m_meshWorldTM, m_meshWorldTMInverse, rayOrigin, rayDirection, outPosition, outNormal);
+    }
+
+
+    void SurfaceDataMeshComponent::GetSurfacePoints(const AZ::Vector3& inPosition, SurfacePointList& surfacePointList) const
+    {
+        AZ::Vector3 hitPosition;
+        AZ::Vector3 hitNormal;
+        if (DoRayTrace(inPosition, hitPosition, hitNormal))
+        {
+            SurfacePoint point;
+            point.m_entityId = GetEntityId();
+            point.m_position = hitPosition;
+            point.m_normal = hitNormal;
+            AddMaxValueForMasks(point.m_masks, m_configuration.m_tags, 1.0f);
+            surfacePointList.push_back(point);
+        }
+    }
+
+    AZ::Aabb SurfaceDataMeshComponent::GetSurfaceAabb() const
+    {
+        return m_meshBounds;
+    }
+
+    SurfaceTagVector SurfaceDataMeshComponent::GetSurfaceTags() const
+    {
+        return m_configuration.m_tags;
+    }
+
+    void SurfaceDataMeshComponent::OnCompositionChanged()
+    {
+        if (!m_refresh)
+        {
+            m_refresh = true;
+            AZ::TickBus::Handler::BusConnect();
+        }
+    }
+
+    void SurfaceDataMeshComponent::OnMeshDestroyed()
+    {
+        OnCompositionChanged();
+    }
+
+    void SurfaceDataMeshComponent::OnMeshCreated(const AZ::Data::Asset<AZ::Data::AssetData>& asset)
+    {
+        (void)asset;
+        OnCompositionChanged();
+    }
+
+    void SurfaceDataMeshComponent::OnBoundsReset()
+    {
+        OnCompositionChanged();
+    }
+
+    void SurfaceDataMeshComponent::OnTransformChanged(const AZ::Transform & local, const AZ::Transform & world)
+    {
+        (void)local;
+        (void)world;
+        OnCompositionChanged();
+    }
+
+    void SurfaceDataMeshComponent::OnTick(float /*deltaTime*/, AZ::ScriptTimePoint /*time*/)
+    {
+        if (m_refresh)
+        {
+            UpdateMeshData();
+            m_refresh = false;
+        }
+        AZ::TickBus::Handler::BusDisconnect();
+    }
+
+    void SurfaceDataMeshComponent::UpdateMeshData()
+    {
+        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+
+        bool meshValidBeforeUpdate = false;
+        bool meshValidAfterUpdate = false;
+
+        {
+            AZStd::lock_guard<decltype(m_cacheMutex)> lock(m_cacheMutex);
+
+            meshValidBeforeUpdate = (m_meshAssetData.GetAs<LmbrCentral::MeshAsset>() != nullptr) && (m_meshBounds.IsValid());
+
+            m_meshAssetData = {};
+            LmbrCentral::MeshComponentRequestBus::EventResult(m_meshAssetData, GetEntityId(), &LmbrCentral::MeshComponentRequestBus::Events::GetMeshAsset);
+
+            m_meshBounds = AZ::Aabb::CreateNull();
+            LmbrCentral::MeshComponentRequestBus::EventResult(m_meshBounds, GetEntityId(), &LmbrCentral::MeshComponentRequestBus::Events::GetWorldBounds);
+
+            m_meshWorldTM = AZ::Transform::CreateIdentity();
+            AZ::TransformBus::EventResult(m_meshWorldTM, GetEntityId(), &AZ::TransformBus::Events::GetWorldTM);
+            m_meshWorldTMInverse = m_meshWorldTM.GetInverse();
+
+            meshValidAfterUpdate = (m_meshAssetData.GetAs<LmbrCentral::MeshAsset>() != nullptr) && (m_meshBounds.IsValid());
+        }
+
+        SurfaceDataRegistryEntry registryEntry;
+        registryEntry.m_entityId = GetEntityId();
+        registryEntry.m_bounds = GetSurfaceAabb();
+        registryEntry.m_tags = GetSurfaceTags();
+
+        if (!meshValidBeforeUpdate && !meshValidAfterUpdate)
+        {
+            // We didn't have a valid mesh asset before or after running this, so do nothing.
+        }
+        else if (!meshValidBeforeUpdate && meshValidAfterUpdate)
+        {
+            // Our mesh has become valid, so register as a provider and save off the provider handle
+            AZ_Assert((m_providerHandle == InvalidSurfaceDataRegistryHandle), "Surface data handle is initialized before our mesh became active");
+            AZ_Assert(m_meshBounds.IsValid(), "Mesh Geometry isn't correctly initialized.");
+            SurfaceDataSystemRequestBus::BroadcastResult(m_providerHandle, &SurfaceDataSystemRequestBus::Events::RegisterSurfaceDataProvider, registryEntry);
+
+            // Start listening for surface data events
+            AZ_Assert((m_providerHandle != InvalidSurfaceDataRegistryHandle), "Invalid surface data handle");
+            SurfaceDataProviderRequestBus::Handler::BusConnect(m_providerHandle);
+        }
+        else if (meshValidBeforeUpdate && !meshValidAfterUpdate)
+        {
+            // Our mesh has stopped being valid, so unregister and stop listening for surface data events
+            AZ_Assert((m_providerHandle != InvalidSurfaceDataRegistryHandle), "Invalid surface data handle");
+            SurfaceDataSystemRequestBus::Broadcast(&SurfaceDataSystemRequestBus::Events::UnregisterSurfaceDataProvider, m_providerHandle);
+            m_providerHandle = InvalidSurfaceDataRegistryHandle;
+
+            SurfaceDataProviderRequestBus::Handler::BusDisconnect();
+        }
+        else if (meshValidBeforeUpdate && meshValidAfterUpdate)
+        {
+            // Our mesh was valid before and after, it just changed in some way, so update our registry entry.
+            AZ_Assert((m_providerHandle != InvalidSurfaceDataRegistryHandle), "Invalid surface data handle");
+            SurfaceDataSystemRequestBus::Broadcast(&SurfaceDataSystemRequestBus::Events::UpdateSurfaceDataProvider, m_providerHandle, registryEntry);
+        }
+    }
+}

Gems/SurfaceData/Code/Source/Components/SurfaceDataMeshComponent.h

@@ -0,0 +1,110 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <AzCore/Asset/AssetCommon.h>
+#include <AzCore/Component/Component.h>
+#include <AzCore/Component/TickBus.h>
+#include <AzCore/Component/TransformBus.h>
+#include <AzCore/std/containers/unordered_map.h>
+#include <LmbrCentral/Rendering/MeshComponentBus.h>
+#include <SurfaceData/SurfaceDataProviderRequestBus.h>
+#include <SurfaceData/SurfaceDataTypes.h>
+
+namespace LmbrCentral
+{
+    class MeshAsset;
+
+    template<typename, typename>
+    class EditorWrappedComponentBase;
+}
+
+namespace SurfaceData
+{
+    constexpr float s_rayAABBHeightPadding = 0.1f;
+
+    class SurfaceDataMeshConfig
+        : public AZ::ComponentConfig
+    {
+    public:
+        AZ_CLASS_ALLOCATOR(SurfaceDataMeshConfig, AZ::SystemAllocator, 0);
+        AZ_RTTI(SurfaceDataMeshConfig, "{764C602E-7CA8-4BCC-AB2D-3E46623B3A20}", AZ::ComponentConfig);
+        static void Reflect(AZ::ReflectContext* context);
+        SurfaceTagVector m_tags;
+    };
+
+    class SurfaceDataMeshComponent
+        : public AZ::Component
+        , public AZ::TickBus::Handler
+        , public AZ::TransformNotificationBus::Handler
+        , public LmbrCentral::MeshComponentNotificationBus::Handler
+        , public SurfaceDataProviderRequestBus::Handler
+    {
+    public:
+        template<typename, typename> friend class LmbrCentral::EditorWrappedComponentBase;
+        AZ_COMPONENT(SurfaceDataMeshComponent, "{F8915F34-BE8B-40B4-B7E8-01EBF3DA1C95}");
+        static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& services);
+        static void GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& services);
+        static void GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& services);
+        static void Reflect(AZ::ReflectContext* context);
+
+        SurfaceDataMeshComponent(const SurfaceDataMeshConfig& configuration);
+        SurfaceDataMeshComponent() = default;
+        ~SurfaceDataMeshComponent() = default;
+
+        //////////////////////////////////////////////////////////////////////////
+        // AZ::Component interface implementation
+        void Activate() override;
+        void Deactivate() override;
+        bool ReadInConfig(const AZ::ComponentConfig* baseConfig) override;
+        bool WriteOutConfig(AZ::ComponentConfig* outBaseConfig) const override;
+
+        //////////////////////////////////////////////////////////////////////////
+        // MeshComponentNotificationBus
+        void OnMeshCreated(const AZ::Data::Asset<AZ::Data::AssetData>& asset) override;
+        void OnMeshDestroyed() override;
+        void OnBoundsReset() override;;
+
+        //////////////////////////////////////////////////////////////////////////
+        // TransformNotificationBus
+        void OnTransformChanged(const AZ::Transform& local, const AZ::Transform& world) override;
+
+        ////////////////////////////////////////////////////////////////////////
+        // AZ::TickBus
+        void OnTick(float deltaTime, AZ::ScriptTimePoint time) override;
+
+        ////////////////////////////////////////////////////////////////////////
+        // SurfaceDataProviderRequestBus
+        void GetSurfacePoints(const AZ::Vector3& inPosition, SurfacePointList& surfacePointList) const override;
+
+    private:
+        bool DoRayTrace(const AZ::Vector3& inPosition, AZ::Vector3& outPosition, AZ::Vector3& outNormal) const;
+        void UpdateMeshData();
+        void OnCompositionChanged();
+
+        AZ::Aabb GetSurfaceAabb() const;
+        SurfaceTagVector GetSurfaceTags() const;
+
+        SurfaceDataMeshConfig m_configuration;
+
+        SurfaceDataRegistryHandle m_providerHandle = InvalidSurfaceDataRegistryHandle;
+
+        // cached data
+        AZStd::atomic_bool m_refresh{ false };
+        mutable AZStd::recursive_mutex m_cacheMutex;
+        AZ::Data::Asset<AZ::Data::AssetData> m_meshAssetData;
+        AZ::Transform m_meshWorldTM = AZ::Transform::CreateIdentity();
+        AZ::Transform m_meshWorldTMInverse = AZ::Transform::CreateIdentity();
+        AZ::Aabb m_meshBounds = AZ::Aabb::CreateNull();
+    };
+}

Gems/SurfaceData/Code/Source/Components/SurfaceDataShapeComponent.cpp

@@ -0,0 +1,296 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensor's.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include "SurfaceData_precompiled.h"
+#include "SurfaceDataShapeComponent.h"
+
+#include <AzCore/Component/TransformBus.h>
+#include <AzCore/Debug/Profiler.h>
+#include <AzCore/Serialization/EditContext.h>
+#include <AzCore/Serialization/SerializeContext.h>
+#include <SurfaceData/SurfaceDataSystemRequestBus.h>
+#include <SurfaceData/Utility/SurfaceDataUtility.h>
+
+namespace SurfaceData
+{
+    void SurfaceDataShapeConfig::Reflect(AZ::ReflectContext* context)
+    {
+        AZ::SerializeContext* serialize = azrtti_cast<AZ::SerializeContext*>(context);
+        if (serialize)
+        {
+            serialize->Class<SurfaceDataShapeConfig, AZ::ComponentConfig>()
+                ->Version(0)
+                ->Field("ProviderTags", &SurfaceDataShapeConfig::m_providerTags)
+                ->Field("ModifierTags", &SurfaceDataShapeConfig::m_modifierTags)
+                ;
+
+            AZ::EditContext* edit = serialize->GetEditContext();
+            if (edit)
+            {
+                edit->Class<SurfaceDataShapeConfig>(
+                    "Shape Surface Tag Emitter", "")
+                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                    ->Attribute(AZ::Edit::Attributes::Visibility, AZ::Edit::PropertyVisibility::ShowChildrenOnly)
+                    ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
+                    ->DataElement(0, &SurfaceDataShapeConfig::m_providerTags, "Generated Tags", "Surface tags to add to created points")
+                    ->DataElement(0, &SurfaceDataShapeConfig::m_modifierTags, "Extended Tags", "Surface tags to add to contained points")
+                    ;
+            }
+        }
+    }
+
+    void SurfaceDataShapeComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& services)
+    {
+        services.push_back(AZ_CRC("SurfaceDataProviderService", 0xfe9fb95e));
+        services.push_back(AZ_CRC("SurfaceDataModifierService", 0x68f8aa72));
+    }
+
+    void SurfaceDataShapeComponent::GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& services)
+    {
+        services.push_back(AZ_CRC("SurfaceDataProviderService", 0xfe9fb95e));
+        services.push_back(AZ_CRC("SurfaceDataModifierService", 0x68f8aa72));
+    }
+
+    void SurfaceDataShapeComponent::GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& services)
+    {
+        services.push_back(AZ_CRC("ShapeService", 0xe86aa5fe));
+    }
+
+    void SurfaceDataShapeComponent::Reflect(AZ::ReflectContext* context)
+    {
+        SurfaceDataShapeConfig::Reflect(context);
+
+        AZ::SerializeContext* serialize = azrtti_cast<AZ::SerializeContext*>(context);
+        if (serialize)
+        {
+            serialize->Class<SurfaceDataShapeComponent, AZ::Component>()
+                ->Version(0)
+                ->Field("Configuration", &SurfaceDataShapeComponent::m_configuration)
+                ;
+        }
+    }
+
+    SurfaceDataShapeComponent::SurfaceDataShapeComponent(const SurfaceDataShapeConfig& configuration)
+        : m_configuration(configuration)
+    {
+    }
+
+    void SurfaceDataShapeComponent::Activate()
+    {
+        m_providerHandle = InvalidSurfaceDataRegistryHandle;
+        m_modifierHandle = InvalidSurfaceDataRegistryHandle;
+        m_refresh = false;
+
+        AZ::TransformNotificationBus::Handler::BusConnect(GetEntityId());
+        LmbrCentral::ShapeComponentNotificationsBus::Handler::BusConnect(GetEntityId());
+
+        // Update the cached shape data and bounds, then register the surface data provider / modifier
+        UpdateShapeData();
+    }
+
+    void SurfaceDataShapeComponent::Deactivate()
+    {
+        if (m_providerHandle != InvalidSurfaceDataRegistryHandle)
+        {
+            SurfaceDataSystemRequestBus::Broadcast(&SurfaceDataSystemRequestBus::Events::UnregisterSurfaceDataProvider, m_providerHandle);
+            m_providerHandle = InvalidSurfaceDataRegistryHandle;
+        }
+        if (m_modifierHandle != InvalidSurfaceDataRegistryHandle)
+        {
+            SurfaceDataSystemRequestBus::Broadcast(&SurfaceDataSystemRequestBus::Events::UnregisterSurfaceDataModifier, m_modifierHandle);
+            m_modifierHandle = InvalidSurfaceDataRegistryHandle;
+
+        }
+
+        m_refresh = false;
+        AZ::TickBus::Handler::BusDisconnect();
+        AZ::TransformNotificationBus::Handler::BusDisconnect();
+        LmbrCentral::ShapeComponentNotificationsBus::Handler::BusDisconnect();
+        SurfaceDataProviderRequestBus::Handler::BusDisconnect();
+        SurfaceDataModifierRequestBus::Handler::BusDisconnect();
+
+        // Clear the cached shape data
+        {
+            AZStd::lock_guard<decltype(m_cacheMutex)> lock(m_cacheMutex);
+            m_shapeBounds = AZ::Aabb::CreateNull();
+            m_shapeBoundsIsValid = false;
+        }
+    }
+
+    bool SurfaceDataShapeComponent::ReadInConfig(const AZ::ComponentConfig* baseConfig)
+    {
+        if (auto config = azrtti_cast<const SurfaceDataShapeConfig*>(baseConfig))
+        {
+            m_configuration = *config;
+            return true;
+        }
+        return false;
+    }
+
+    bool SurfaceDataShapeComponent::WriteOutConfig(AZ::ComponentConfig* outBaseConfig) const
+    {
+        if (auto config = azrtti_cast<SurfaceDataShapeConfig*>(outBaseConfig))
+        {
+            *config = m_configuration;
+            return true;
+        }
+        return false;
+    }
+
+    void SurfaceDataShapeComponent::GetSurfacePoints(const AZ::Vector3& inPosition, SurfacePointList& surfacePointList) const
+    {
+        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+
+        AZStd::lock_guard<decltype(m_cacheMutex)> lock(m_cacheMutex);
+
+        if (m_shapeBoundsIsValid)
+        {
+            const AZ::Vector3 rayOrigin = AZ::Vector3(inPosition.GetX(), inPosition.GetY(), m_shapeBounds.GetMax().GetZ());
+            const AZ::Vector3 rayDirection = -AZ::Vector3::CreateAxisZ();
+            float intersectionDistance = 0.0f;
+            bool hitShape = false;
+            LmbrCentral::ShapeComponentRequestsBus::EventResult(hitShape, GetEntityId(), &LmbrCentral::ShapeComponentRequestsBus::Events::IntersectRay, rayOrigin, rayDirection, intersectionDistance);
+            if (hitShape)
+            {
+                SurfacePoint point;
+                point.m_entityId = GetEntityId();
+                point.m_position = rayOrigin + intersectionDistance * rayDirection;
+                point.m_normal = AZ::Vector3::CreateAxisZ();
+                AddMaxValueForMasks(point.m_masks, m_configuration.m_providerTags, 1.0f);
+                surfacePointList.push_back(point);
+            }
+        }
+    }
+
+    void SurfaceDataShapeComponent::ModifySurfacePoints(SurfacePointList& surfacePointList) const
+    {
+        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+
+        AZStd::lock_guard<decltype(m_cacheMutex)> lock(m_cacheMutex);
+
+        if (m_shapeBoundsIsValid && !m_configuration.m_modifierTags.empty())
+        {
+            const AZ::EntityId entityId = GetEntityId();
+            for (auto& point : surfacePointList)
+            {
+                if (point.m_entityId != entityId && m_shapeBounds.Contains(point.m_position))
+                {
+                    bool inside = false;
+                    LmbrCentral::ShapeComponentRequestsBus::EventResult(inside, GetEntityId(), &LmbrCentral::ShapeComponentRequestsBus::Events::IsPointInside, point.m_position);
+                    if (inside)
+                    {
+                        AddMaxValueForMasks(point.m_masks, m_configuration.m_modifierTags, 1.0f);
+                    }
+                }
+            }
+        }
+    }
+
+    void SurfaceDataShapeComponent::OnTransformChanged(const AZ::Transform& /*local*/, const AZ::Transform& /*world*/)
+    {
+        OnCompositionChanged();
+    }
+
+    void SurfaceDataShapeComponent::OnShapeChanged([[maybe_unused]] ShapeChangeReasons changeReason)
+    {
+        OnCompositionChanged();
+    }
+
+    void SurfaceDataShapeComponent::OnTick(float /*deltaTime*/, AZ::ScriptTimePoint /*time*/)
+    {
+        if (m_refresh)
+        {
+            UpdateShapeData();
+            m_refresh = false;
+        }
+        AZ::TickBus::Handler::BusDisconnect();
+    }
+
+    void SurfaceDataShapeComponent::OnCompositionChanged()
+    {
+        if (!m_refresh)
+        {
+            m_refresh = true;
+            AZ::TickBus::Handler::BusConnect();
+        }
+    }
+
+    void SurfaceDataShapeComponent::UpdateShapeData()
+    {
+        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+
+        bool shapeValidBeforeUpdate = false;
+        bool shapeValidAfterUpdate = false;
+
+        {
+            AZStd::lock_guard<decltype(m_cacheMutex)> lock(m_cacheMutex);
+
+            shapeValidBeforeUpdate = m_shapeBoundsIsValid;
+
+            m_shapeBounds = AZ::Aabb::CreateNull();
+            LmbrCentral::ShapeComponentRequestsBus::EventResult(m_shapeBounds, GetEntityId(), &LmbrCentral::ShapeComponentRequestsBus::Events::GetEncompassingAabb);
+            m_shapeBoundsIsValid = m_shapeBounds.IsValid();
+
+            shapeValidAfterUpdate = m_shapeBoundsIsValid;
+        }
+
+        SurfaceDataRegistryEntry providerRegistryEntry;
+        providerRegistryEntry.m_entityId = GetEntityId();
+        providerRegistryEntry.m_bounds = m_shapeBounds;
+        providerRegistryEntry.m_tags = m_configuration.m_providerTags;
+
+        SurfaceDataRegistryEntry modifierRegistryEntry(providerRegistryEntry);
+        modifierRegistryEntry.m_tags = m_configuration.m_modifierTags;
+
+        if (shapeValidBeforeUpdate && shapeValidAfterUpdate)
+        {
+            // Our shape was valid before and after, it just changed in some way, so update our registry entries
+            AZ_Assert((m_providerHandle != InvalidSurfaceDataRegistryHandle), "Invalid surface data handle");
+            AZ_Assert((m_modifierHandle != InvalidSurfaceDataRegistryHandle), "Invalid modifier data handle");
+            SurfaceDataSystemRequestBus::Broadcast(&SurfaceDataSystemRequestBus::Events::UpdateSurfaceDataProvider, m_providerHandle, providerRegistryEntry);
+            SurfaceDataSystemRequestBus::Broadcast(&SurfaceDataSystemRequestBus::Events::UpdateSurfaceDataModifier, m_modifierHandle, modifierRegistryEntry);
+        }
+        else if (!shapeValidBeforeUpdate && shapeValidAfterUpdate)
+        {
+            // Our shape has become valid, so register as a provider and save off the registry handles
+            AZ_Assert((m_providerHandle == InvalidSurfaceDataRegistryHandle), "Surface Provider data handle is initialized before our shape became valid");
+            AZ_Assert((m_modifierHandle == InvalidSurfaceDataRegistryHandle), "Surface Modifier data handle is initialized before our shape became valid");
+            SurfaceDataSystemRequestBus::BroadcastResult(m_providerHandle, &SurfaceDataSystemRequestBus::Events::RegisterSurfaceDataProvider, providerRegistryEntry);
+            SurfaceDataSystemRequestBus::BroadcastResult(m_modifierHandle, &SurfaceDataSystemRequestBus::Events::RegisterSurfaceDataModifier, modifierRegistryEntry);
+
+            // Start listening for surface data events
+            AZ_Assert((m_providerHandle != InvalidSurfaceDataRegistryHandle), "Invalid surface data handle");
+            AZ_Assert((m_modifierHandle != InvalidSurfaceDataRegistryHandle), "Invalid surface data handle");
+            SurfaceDataProviderRequestBus::Handler::BusConnect(m_providerHandle);
+            SurfaceDataModifierRequestBus::Handler::BusConnect(m_modifierHandle);
+        }
+        else if (shapeValidBeforeUpdate && !shapeValidAfterUpdate)
+        {
+            // Our shape has stopped being valid, so unregister and stop listening for surface data events
+            AZ_Assert((m_providerHandle != InvalidSurfaceDataRegistryHandle), "Invalid surface data handle");
+            AZ_Assert((m_modifierHandle != InvalidSurfaceDataRegistryHandle), "Invalid surface data handle");
+            SurfaceDataSystemRequestBus::Broadcast(&SurfaceDataSystemRequestBus::Events::UnregisterSurfaceDataProvider, m_providerHandle);
+            SurfaceDataSystemRequestBus::Broadcast(&SurfaceDataSystemRequestBus::Events::UnregisterSurfaceDataModifier, m_modifierHandle);
+            m_providerHandle = InvalidSurfaceDataRegistryHandle;
+            m_modifierHandle = InvalidSurfaceDataRegistryHandle;
+
+            SurfaceDataProviderRequestBus::Handler::BusDisconnect();
+            SurfaceDataModifierRequestBus::Handler::BusDisconnect();
+        }
+        else
+        {
+            // We didn't have a valid shape before or after running this, so do nothing.
+        }
+    }
+
+    const float SurfaceDataShapeComponent::s_rayAABBHeightPadding = 0.1f;
+}

Gems/SurfaceData/Code/Source/Components/SurfaceDataShapeComponent.h

@@ -0,0 +1,104 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <AzCore/Component/Component.h>
+#include <AzCore/Component/TickBus.h>
+#include <AzCore/Component/TransformBus.h>
+#include <LmbrCentral/Shape/ShapeComponentBus.h>
+#include <SurfaceData/SurfaceDataModifierRequestBus.h>
+#include <SurfaceData/SurfaceDataProviderRequestBus.h>
+#include <SurfaceData/SurfaceDataTypes.h>
+
+namespace LmbrCentral
+{
+    template<typename, typename>
+    class EditorWrappedComponentBase;
+}
+
+namespace SurfaceData
+{
+    class SurfaceDataShapeConfig
+        : public AZ::ComponentConfig
+    {
+    public:
+        AZ_CLASS_ALLOCATOR(SurfaceDataShapeConfig, AZ::SystemAllocator, 0);
+        AZ_RTTI(SurfaceDataShapeConfig, "{1EE196EF-8986-4A2B-B8DD-DA73F85CD597}", AZ::ComponentConfig);
+        static void Reflect(AZ::ReflectContext* context);
+        SurfaceTagVector m_providerTags;
+        SurfaceTagVector m_modifierTags;
+    };
+
+    class SurfaceDataShapeComponent
+        : public AZ::Component
+        , private AZ::TickBus::Handler
+        , private AZ::TransformNotificationBus::Handler
+        , private LmbrCentral::ShapeComponentNotificationsBus::Handler
+        , private SurfaceDataModifierRequestBus::Handler
+        , private SurfaceDataProviderRequestBus::Handler
+    {
+    public:
+        template<typename, typename> friend class LmbrCentral::EditorWrappedComponentBase;
+        AZ_COMPONENT(SurfaceDataShapeComponent, "{F746C7F6-EF59-45C3-AB5C-011F7AC43415}");
+        static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& services);
+        static void GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& services);
+        static void GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& services);
+        static void Reflect(AZ::ReflectContext* context);
+
+        SurfaceDataShapeComponent(const SurfaceDataShapeConfig& configuration);
+        SurfaceDataShapeComponent() = default;
+        ~SurfaceDataShapeComponent() = default;
+
+        //////////////////////////////////////////////////////////////////////////
+        // AZ::Component interface implementation
+        void Activate() override;
+        void Deactivate() override;
+        bool ReadInConfig(const AZ::ComponentConfig* baseConfig) override;
+        bool WriteOutConfig(AZ::ComponentConfig* outBaseConfig) const override;
+
+        //////////////////////////////////////////////////////////////////////////
+        // SurfaceDataProviderRequestBus
+        void GetSurfacePoints(const AZ::Vector3& inPosition, SurfacePointList& surfacePointList) const;
+
+        //////////////////////////////////////////////////////////////////////////
+        // SurfaceDataModifierRequestBus
+        void ModifySurfacePoints(SurfacePointList& surfacePointList) const override;
+
+        //////////////////////////////////////////////////////////////////////////
+        // AZ::TransformNotificationBus
+        void OnTransformChanged(const AZ::Transform& /*local*/, const AZ::Transform& /*world*/) override;
+
+        // ShapeComponentNotificationsBus
+        void OnShapeChanged(ShapeChangeReasons changeReason) override;
+
+        ////////////////////////////////////////////////////////////////////////
+        // AZ::TickBus
+        void OnTick(float deltaTime, AZ::ScriptTimePoint time) override;
+
+    private:
+        void OnCompositionChanged();
+        void UpdateShapeData();
+
+        SurfaceDataShapeConfig m_configuration;
+
+        SurfaceDataRegistryHandle m_providerHandle = InvalidSurfaceDataRegistryHandle;
+        SurfaceDataRegistryHandle m_modifierHandle = InvalidSurfaceDataRegistryHandle;
+
+        // cached data
+        AZStd::atomic_bool m_refresh{ false };
+        mutable AZStd::recursive_mutex m_cacheMutex;
+        AZ::Aabb m_shapeBounds = AZ::Aabb::CreateNull();
+        bool m_shapeBoundsIsValid = false;
+        static const float s_rayAABBHeightPadding;
+    };
+}

Gems/SurfaceData/Code/Source/Editor/EditorSurfaceDataColliderComponent.cpp

@@ -0,0 +1,26 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include "SurfaceData_precompiled.h"
+#include "EditorSurfaceDataColliderComponent.h"
+#include <AzCore/Serialization/Utils.h>
+#include <AzToolsFramework/API/ToolsApplicationAPI.h>
+#include <AzToolsFramework/UI/PropertyEditor/PropertyEditorAPI.h>
+#include <LmbrCentral/Dependency/DependencyNotificationBus.h>
+
+namespace SurfaceData
+{
+    void EditorSurfaceDataColliderComponent::Reflect(AZ::ReflectContext* context)
+    {
+        BaseClassType::ReflectSubClass<EditorSurfaceDataColliderComponent, BaseClassType>(context, 2, &LmbrCentral::EditorWrappedComponentBaseVersionConverter<typename BaseClassType::WrappedComponentType, typename BaseClassType::WrappedConfigType,2>);
+    }
+}

Gems/SurfaceData/Code/Source/Editor/EditorSurfaceDataColliderComponent.h

@@ -0,0 +1,38 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <AzCore/Module/Module.h>
+#include <AzToolsFramework/ToolsComponents/EditorComponentBase.h>
+#include <AzToolsFramework/ToolsComponents/EditorVisibilityBus.h>
+#include <Components/SurfaceDataColliderComponent.h>
+#include <LmbrCentral/Component/EditorWrappedComponentBase.h>
+
+namespace SurfaceData
+{
+    class EditorSurfaceDataColliderComponent
+        : public LmbrCentral::EditorWrappedComponentBase<SurfaceDataColliderComponent, SurfaceDataColliderConfig>
+    {
+    public:
+        using BaseClassType = LmbrCentral::EditorWrappedComponentBase<SurfaceDataColliderComponent, SurfaceDataColliderConfig>;
+        AZ_EDITOR_COMPONENT(EditorSurfaceDataColliderComponent, "{0F44367D-B9A3-4C25-A769-24993C8BF7A7}", BaseClassType);
+        static void Reflect(AZ::ReflectContext* context);
+
+        static constexpr const char* const s_categoryName = "Surface Data";
+        static constexpr const char* const s_componentName = "PhysX Collider Surface Tag Emitter";
+        static constexpr const char* const s_componentDescription = "Enables a physics collider to emit surface tags";
+        static constexpr const char* const s_icon = "Editor/Icons/Components/SurfaceData.svg";
+        static constexpr const char* const s_viewportIcon = "Editor/Icons/Components/Viewport/SurfaceData.png";
+        static constexpr const char* const s_helpUrl = "https://docs.aws.amazon.com/console/lumberyard/surfacedata/physics-collider-surface-tag-emitter";
+    };
+}

Gems/SurfaceData/Code/Source/Editor/EditorSurfaceDataMeshComponent.cpp

@@ -0,0 +1,26 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include "SurfaceData_precompiled.h"
+#include "EditorSurfaceDataMeshComponent.h"
+#include <AzCore/Serialization/Utils.h>
+#include <AzToolsFramework/API/ToolsApplicationAPI.h>
+#include <AzToolsFramework/UI/PropertyEditor/PropertyEditorAPI.h>
+#include <LmbrCentral/Dependency/DependencyNotificationBus.h>
+
+namespace SurfaceData
+{
+    void EditorSurfaceDataMeshComponent::Reflect(AZ::ReflectContext* context)
+    {
+        BaseClassType::ReflectSubClass<EditorSurfaceDataMeshComponent, BaseClassType>(context, 2, &LmbrCentral::EditorWrappedComponentBaseVersionConverter<typename BaseClassType::WrappedComponentType, typename BaseClassType::WrappedConfigType,2>);
+    }
+}

Gems/SurfaceData/Code/Source/Editor/EditorSurfaceDataMeshComponent.h

@@ -0,0 +1,38 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <AzCore/Module/Module.h>
+#include <AzToolsFramework/ToolsComponents/EditorComponentBase.h>
+#include <AzToolsFramework/ToolsComponents/EditorVisibilityBus.h>
+#include <Components/SurfaceDataMeshComponent.h>
+#include <LmbrCentral/Component/EditorWrappedComponentBase.h>
+
+namespace SurfaceData
+{
+    class EditorSurfaceDataMeshComponent
+        : public LmbrCentral::EditorWrappedComponentBase<SurfaceDataMeshComponent, SurfaceDataMeshConfig>
+    {
+    public:
+        using BaseClassType = LmbrCentral::EditorWrappedComponentBase<SurfaceDataMeshComponent, SurfaceDataMeshConfig>;
+        AZ_EDITOR_COMPONENT(EditorSurfaceDataMeshComponent, "{4D73E979-5463-4B75-AE46-70B1E52CBF43}", BaseClassType);
+        static void Reflect(AZ::ReflectContext* context);
+
+        static constexpr const char* const s_categoryName = "Surface Data";
+        static constexpr const char* const s_componentName = "Mesh Surface Tag Emitter";
+        static constexpr const char* const s_componentDescription = "Enables a static mesh to emit surface tags";
+        static constexpr const char* const s_icon = "Editor/Icons/Components/SurfaceData.svg";
+        static constexpr const char* const s_viewportIcon = "Editor/Icons/Components/Viewport/SurfaceData.png";
+        static constexpr const char* const s_helpUrl = "https://docs.aws.amazon.com/console/lumberyard/surfacedata/mesh-surface-tag-emitter";
+    };
+}

Gems/SurfaceData/Code/Source/Editor/EditorSurfaceDataShapeComponent.cpp

@@ -0,0 +1,27 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include "SurfaceData_precompiled.h"
+#include "EditorSurfaceDataShapeComponent.h"
+#include <AzCore/Serialization/Utils.h>
+#include <AzToolsFramework/API/ToolsApplicationAPI.h>
+#include <AzToolsFramework/UI/PropertyEditor/PropertyEditorAPI.h>
+#include <LmbrCentral/Dependency/DependencyNotificationBus.h>
+#include <AzToolsFramework/ToolsComponents/EditorComponentBase.h>
+
+namespace SurfaceData
+{
+    void EditorSurfaceDataShapeComponent::Reflect(AZ::ReflectContext* context)
+    {
+        BaseClassType::ReflectSubClass<EditorSurfaceDataShapeComponent, BaseClassType>(context, 2, &LmbrCentral::EditorWrappedComponentBaseVersionConverter<typename BaseClassType::WrappedComponentType, typename BaseClassType::WrappedConfigType,2>);
+    }
+}

Gems/SurfaceData/Code/Source/Editor/EditorSurfaceDataShapeComponent.h

@@ -0,0 +1,38 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <AzCore/Module/Module.h>
+#include <AzToolsFramework/ToolsComponents/EditorComponentBase.h>
+#include <AzToolsFramework/ToolsComponents/EditorVisibilityBus.h>
+#include <Components/SurfaceDataShapeComponent.h>
+#include <LmbrCentral/Component/EditorWrappedComponentBase.h>
+
+namespace SurfaceData
+{
+    class EditorSurfaceDataShapeComponent
+        : public LmbrCentral::EditorWrappedComponentBase<SurfaceDataShapeComponent, SurfaceDataShapeConfig>
+    {
+    public:
+        using BaseClassType = LmbrCentral::EditorWrappedComponentBase<SurfaceDataShapeComponent, SurfaceDataShapeConfig>;
+        AZ_EDITOR_COMPONENT(EditorSurfaceDataShapeComponent, "{A2E691AC-A027-4B90-A604-689E543BEA91}", BaseClassType);
+        static void Reflect(AZ::ReflectContext* context);
+
+        static constexpr const char* const s_categoryName = "Surface Data";
+        static constexpr const char* const s_componentName = "Shape Surface Tag Emitter";
+        static constexpr const char* const s_componentDescription = "Enables a shape to emit surface tags";
+        static constexpr const char* const s_icon = "Editor/Icons/Components/SurfaceData.svg";
+        static constexpr const char* const s_viewportIcon = "Editor/Icons/Components/Viewport/SurfaceData.png";
+        static constexpr const char* const s_helpUrl = "https://docs.aws.amazon.com/console/lumberyard/surfacedata/shape-surface-tag-emitter";
+    };
+}

Gems/SurfaceData/Code/Source/Editor/EditorSurfaceDataSystemComponent.cpp

@@ -0,0 +1,218 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include "SurfaceData_precompiled.h"
+#include "EditorSurfaceDataSystemComponent.h"
+#include <AzCore/Serialization/SerializeContext.h>
+#include <AzCore/Serialization/EditContext.h>
+#include <AzFramework/Asset/GenericAssetHandler.h>
+#include <AzToolsFramework/UI/PropertyEditor/PropertyEditorAPI.h>
+
+
+namespace SurfaceData
+{
+    namespace Details
+    {
+        AzFramework::GenericAssetHandler<EditorSurfaceTagListAsset>* s_surfaceTagListAssetHandler = nullptr;
+
+        void RegisterAssethandlers()
+        {
+            s_surfaceTagListAssetHandler = aznew AzFramework::GenericAssetHandler<EditorSurfaceTagListAsset>("Surface Tag Name List", "Other", "surfaceTagNameList");
+            s_surfaceTagListAssetHandler->Register();
+        }
+
+        void UnregisterAssethandlers()
+        {
+            if (s_surfaceTagListAssetHandler)
+            {
+                s_surfaceTagListAssetHandler->Unregister();
+                delete s_surfaceTagListAssetHandler;
+                s_surfaceTagListAssetHandler = nullptr;
+            }
+        }
+    }
+
+    void EditorSurfaceDataSystemConfig::Reflect(AZ::ReflectContext* context)
+    {
+        EditorSurfaceTagListAsset::Reflect(context);
+
+        AZ::SerializeContext* serialize = azrtti_cast<AZ::SerializeContext*>(context);
+        if (serialize)
+        {
+            serialize->Class<EditorSurfaceDataSystemConfig, AZ::ComponentConfig>()
+                ->Version(0)
+                ;
+
+            AZ::EditContext* edit = serialize->GetEditContext();
+            if (edit)
+            {
+                edit->Class<EditorSurfaceDataSystemConfig>(
+                    "Editor Surface Data System Config", "")
+                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                    ->Attribute(AZ::Edit::Attributes::Visibility, AZ::Edit::PropertyVisibility::ShowChildrenOnly)
+                    ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
+                    ;
+            }
+        }
+    }
+
+    void EditorSurfaceDataSystemComponent::Reflect(AZ::ReflectContext* context)
+    {
+        EditorSurfaceDataSystemConfig::Reflect(context);
+
+        if (AZ::SerializeContext* serialize = azrtti_cast<AZ::SerializeContext*>(context))
+        {
+            serialize->Class<EditorSurfaceDataSystemComponent, AzToolsFramework::Components::EditorComponentBase>()
+                ->Version(0)
+                ->Field("Configuration", &EditorSurfaceDataSystemComponent::m_configuration)
+                ;
+
+            if (AZ::EditContext* ec = serialize->GetEditContext())
+            {
+                ec->Class<EditorSurfaceDataSystemComponent>("Editor Surface Data System", "Manages discovery and registration of surface tag list assets")
+                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                    ->Attribute(AZ::Edit::Attributes::AppearsInAddComponentMenu, AZ_CRC("System", 0xc94d118b))
+                    ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
+                    ->DataElement(0, &EditorSurfaceDataSystemComponent::m_configuration, "Configuration", "")
+                    ;
+            }
+        }
+    }
+
+    void EditorSurfaceDataSystemComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
+    {
+        provided.push_back(AZ_CRC("SurfaceDataTagProviderService", 0x21e6b583));
+    }
+
+    void EditorSurfaceDataSystemComponent::GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible)
+    {
+        incompatible.push_back(AZ_CRC("SurfaceDataTagProviderService", 0x21e6b583));
+    }
+
+    void EditorSurfaceDataSystemComponent::GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& required)
+    {
+        required.push_back(AZ_CRC("SurfaceDataSystemService", 0x1d44d25f));
+    }
+
+    void EditorSurfaceDataSystemComponent::Init()
+    {
+        AzToolsFramework::Components::EditorComponentBase::Init();
+    }
+
+    void EditorSurfaceDataSystemComponent::Activate()
+    {
+        Details::RegisterAssethandlers();
+        AzFramework::AssetCatalogEventBus::Handler::BusConnect();
+        AzToolsFramework::Components::EditorComponentBase::Activate();
+        SurfaceDataTagProviderRequestBus::Handler::BusConnect();
+    }
+
+    void EditorSurfaceDataSystemComponent::Deactivate()
+    {
+        AzFramework::AssetCatalogEventBus::Handler::BusDisconnect();
+        AzToolsFramework::Components::EditorComponentBase::Deactivate();
+        SurfaceDataTagProviderRequestBus::Handler::BusDisconnect();
+        Details::UnregisterAssethandlers();
+        AZ::Data::AssetBus::MultiHandler::BusDisconnect();
+    }
+
+    void EditorSurfaceDataSystemComponent::GetRegisteredSurfaceTagNames(SurfaceTagNameSet& masks) const
+    {
+        for (const auto& tagName : Constants::s_allTagNames)
+        {
+            masks.insert(tagName);
+        }
+
+        for (const auto& assetPair : m_surfaceTagNameAssets)
+        {
+            const auto& asset = assetPair.second;
+            if (asset.IsReady())
+            {
+                const auto& tags = asset.Get()->m_surfaceTagNames;
+                masks.insert(tags.begin(), tags.end());
+            }
+        }
+    }
+
+    void EditorSurfaceDataSystemComponent::OnCatalogLoaded(const char* /*catalogFile*/)
+    {
+        //automatically register all surface tag list assets
+
+        // First run through all the assets and trigger loads on them.
+        AZ::Data::AssetCatalogRequestBus::Broadcast(&AZ::Data::AssetCatalogRequestBus::Events::EnumerateAssets,
+            nullptr,
+            [this](const AZ::Data::AssetId assetId, const AZ::Data::AssetInfo& assetInfo) {
+                const auto assetType = azrtti_typeid<EditorSurfaceTagListAsset>();
+                if (assetInfo.m_assetType == assetType)
+                {
+                    m_surfaceTagNameAssets[assetId] = AZ::Data::AssetManager::Instance().GetAsset(assetId, assetType, AZ::Data::AssetLoadBehavior::Default);
+                }
+            },
+            nullptr);
+
+        // After all the loads are triggered, block to make sure they've all completed.
+        for (auto& asset : m_surfaceTagNameAssets)
+        {
+            asset.second.BlockUntilLoadComplete();
+        }
+    }
+
+    void EditorSurfaceDataSystemComponent::OnCatalogAssetAdded(const AZ::Data::AssetId& assetId)
+    {
+        AZ::Data::AssetInfo assetInfo;
+        AZ::Data::AssetCatalogRequestBus::BroadcastResult(assetInfo, &AZ::Data::AssetCatalogRequests::GetAssetInfoById, assetId);
+
+        const auto assetType = azrtti_typeid<EditorSurfaceTagListAsset>();
+        if (assetInfo.m_assetType == assetType)
+        {
+            AZ::Data::AssetBus::MultiHandler::BusConnect(assetId);
+        }
+    }
+
+    void EditorSurfaceDataSystemComponent::OnCatalogAssetChanged(const AZ::Data::AssetId& assetId)
+    {
+        AZ::Data::AssetInfo assetInfo;
+        AZ::Data::AssetCatalogRequestBus::BroadcastResult(assetInfo, &AZ::Data::AssetCatalogRequests::GetAssetInfoById, assetId);
+
+        const auto assetType = azrtti_typeid<EditorSurfaceTagListAsset>();
+        if (assetInfo.m_assetType == assetType)
+        {
+            AZ::Data::AssetBus::MultiHandler::BusConnect(assetId);
+        }
+    }
+
+    void EditorSurfaceDataSystemComponent::OnCatalogAssetRemoved(const AZ::Data::AssetId& assetId, const AZ::Data::AssetInfo& /*assetInfo*/)
+    {
+        m_surfaceTagNameAssets.erase(assetId);
+    }
+
+    void EditorSurfaceDataSystemComponent::OnAssetReloaded(AZ::Data::Asset<AZ::Data::AssetData> asset)
+    {
+        OnAssetReady(asset);
+    }
+
+    void EditorSurfaceDataSystemComponent::OnAssetReady(AZ::Data::Asset<AZ::Data::AssetData> asset)
+    {
+        AZ::Data::AssetBus::MultiHandler::BusDisconnect(asset.GetId());
+        AddAsset(asset);
+    }
+
+    void EditorSurfaceDataSystemComponent::AddAsset(AZ::Data::Asset<AZ::Data::AssetData>& asset)
+    {
+        const auto assetType = azrtti_typeid<EditorSurfaceTagListAsset>();
+        if (asset.GetType() == assetType)
+        {
+            m_surfaceTagNameAssets[asset.GetId()] = asset;
+            AzToolsFramework::PropertyEditorGUIMessages::Bus::Broadcast(&AzToolsFramework::PropertyEditorGUIMessages::RequestRefresh, AzToolsFramework::PropertyModificationRefreshLevel::Refresh_AttributesAndValues);
+        }
+    }
+}

Gems/SurfaceData/Code/Source/Editor/EditorSurfaceDataSystemComponent.h

@@ -0,0 +1,82 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include "EditorSurfaceTagListAsset.h"
+#include <AzCore/Component/Component.h>
+#include <AzCore/Asset/AssetCommon.h>
+#include <AzFramework/Asset/AssetCatalogBus.h>
+#include <AzToolsFramework/ToolsComponents/EditorComponentBase.h>
+#include <SurfaceData/SurfaceDataTagProviderRequestBus.h>
+
+namespace AZ::Data
+{
+    class AssetInfo;
+}
+
+namespace SurfaceData
+{
+    class EditorSurfaceDataSystemConfig
+        : public AZ::ComponentConfig
+    {
+    public:
+        AZ_CLASS_ALLOCATOR(EditorSurfaceDataSystemConfig, AZ::SystemAllocator, 0);
+        AZ_RTTI(EditorSurfaceDataSystemConfig, "{13B511DF-B649-474C-AC32-1E1026DBB303}", AZ::ComponentConfig);
+        static void Reflect(AZ::ReflectContext* context);
+    };
+
+    class EditorSurfaceDataSystemComponent
+        : public AzToolsFramework::Components::EditorComponentBase
+        , private AzFramework::AssetCatalogEventBus::Handler
+        , private SurfaceDataTagProviderRequestBus::Handler
+        , private AZ::Data::AssetBus::MultiHandler
+    {
+    public:
+        AZ_EDITOR_COMPONENT(EditorSurfaceDataSystemComponent, "{F3EE5137-856B-4E29-AADD-84F358AEA75F}");
+
+        static void Reflect(AZ::ReflectContext* context);
+
+        static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided);
+        static void GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible);
+        static void GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& required);
+
+    private:
+
+        void AddAsset(AZ::Data::Asset<AZ::Data::AssetData>& asset);
+
+        ////////////////////////////////////////////////////////////////////////
+        // AZ::Component interface implementation
+        void Init() override;
+        void Activate() override;
+        void Deactivate() override;
+
+        ////////////////////////////////////////////////////////////////////////
+        // SurfaceDataTagProviderRequestBus
+        void GetRegisteredSurfaceTagNames(SurfaceTagNameSet& names) const override;
+
+        ////////////////////////////////////////////////////////////////////////
+        // AzFramework::AssetCatalogEventBus
+        void OnCatalogLoaded(const char* /*catalogFile*/) override;
+        void OnCatalogAssetChanged(const AZ::Data::AssetId& assetId) override;
+        void OnCatalogAssetAdded(const AZ::Data::AssetId& assetId) override;
+        void OnCatalogAssetRemoved(const AZ::Data::AssetId& assetId, const AZ::Data::AssetInfo& assetInfo) override;
+
+        ////////////////////////////////////////////////////////////////////////
+        // AZ::Data::AssetBus
+        void OnAssetReloaded(AZ::Data::Asset<AZ::Data::AssetData> asset) override;
+        void OnAssetReady(AZ::Data::Asset<AZ::Data::AssetData> asset) override;
+
+        EditorSurfaceDataSystemConfig m_configuration;
+        AZStd::unordered_map<AZ::Data::AssetId, AZ::Data::Asset<EditorSurfaceTagListAsset>> m_surfaceTagNameAssets;
+    };
+}

Gems/SurfaceData/Code/Source/Editor/EditorSurfaceTagListAsset.cpp

@@ -0,0 +1,44 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include "SurfaceData_precompiled.h"
+#include "EditorSurfaceTagListAsset.h"
+#include <AzCore/Serialization/EditContext.h>
+#include <AzCore/Serialization/SerializeContext.h>
+
+namespace SurfaceData
+{
+    void EditorSurfaceTagListAsset::Reflect(AZ::ReflectContext* context)
+    {
+        AZ::SerializeContext* serialize = azrtti_cast<AZ::SerializeContext*>(context);
+        if (serialize)
+        {
+            serialize->Class<EditorSurfaceTagListAsset>()
+                ->Attribute(AZ::Edit::Attributes::EnableForAssetEditor, true)
+                ->Version(0)
+                ->Field("SurfaceTagNames", &EditorSurfaceTagListAsset::m_surfaceTagNames)
+                ;
+
+            AZ::EditContext* edit = serialize->GetEditContext();
+            if (edit)
+            {
+                edit->Class<EditorSurfaceTagListAsset>(
+                    "Surface Tag Name List Asset", "Contains a list of tag names")
+                    ->DataElement(0, &EditorSurfaceTagListAsset::m_surfaceTagNames, "Surface Tag Name List", "")
+                        ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
+                        ->Attribute(AZ::Edit::Attributes::ContainerCanBeModified, true)
+                        ->ElementAttribute(AZ::Edit::Attributes::MaxLength, 64)
+                    ;
+            }
+        }
+    }
+}

Gems/SurfaceData/Code/Source/Editor/EditorSurfaceTagListAsset.h

@@ -0,0 +1,38 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+#pragma once
+
+#include <AzCore/Asset/AssetCommon.h>
+#include <AzCore/RTTI/RTTI.h>
+
+namespace AZ
+{
+    class ReflectContext;
+}
+
+namespace SurfaceData
+{
+    /**
+    * Asset containing dictionary of known tags
+    */
+    class EditorSurfaceTagListAsset final
+        : public AZ::Data::AssetData
+    {
+    public:
+        AZ_RTTI(EditorSurfaceTagListAsset, "{A471B2A9-85FC-4993-842D-1881CBC03A2B}", AZ::Data::AssetData);
+        AZ_CLASS_ALLOCATOR(EditorSurfaceTagListAsset, AZ::SystemAllocator, 0);
+        static void Reflect(AZ::ReflectContext* context);
+    
+        AZStd::vector<AZStd::string> m_surfaceTagNames;
+    };
+
+} // namespace SurfaceData

Gems/SurfaceData/Code/Source/SurfaceDataEditorModule.cpp

@@ -0,0 +1,41 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include "SurfaceData_precompiled.h"
+#include <SurfaceDataEditorModule.h>
+#include <SurfaceDataSystemComponent.h>
+#include <Editor/EditorSurfaceDataSystemComponent.h>
+#include <Editor/EditorSurfaceDataColliderComponent.h>
+#include <Editor/EditorSurfaceDataMeshComponent.h>
+#include <Editor/EditorSurfaceDataShapeComponent.h>
+
+namespace SurfaceData
+{
+    SurfaceDataEditorModule::SurfaceDataEditorModule()
+    {
+        m_descriptors.insert(m_descriptors.end(), {
+            EditorSurfaceDataSystemComponent::CreateDescriptor(),
+            EditorSurfaceDataColliderComponent::CreateDescriptor(),
+            EditorSurfaceDataMeshComponent::CreateDescriptor(),
+            EditorSurfaceDataShapeComponent::CreateDescriptor()
+        });
+    }
+
+    AZ::ComponentTypeList SurfaceDataEditorModule::GetRequiredSystemComponents() const
+    {
+        AZ::ComponentTypeList requiredComponents = SurfaceDataModule::GetRequiredSystemComponents();
+        requiredComponents.push_back(azrtti_typeid<EditorSurfaceDataSystemComponent>());
+        return requiredComponents;
+    }
+}
+
+AZ_DECLARE_MODULE_CLASS(Gem_SurfaceDataEditor, SurfaceData::SurfaceDataEditorModule)

Gems/SurfaceData/Code/Source/SurfaceDataEditorModule.h

@@ -0,0 +1,31 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include "SurfaceData_precompiled.h"
+#include <SurfaceDataModule.h>
+
+namespace SurfaceData
+{
+    class SurfaceDataEditorModule
+        : public SurfaceDataModule
+    {
+    public:
+        AZ_RTTI(SurfaceDataEditorModule, "{B80F2321-B79A-4161-B586-3E508655DFAF}", SurfaceDataModule);
+        AZ_CLASS_ALLOCATOR(SurfaceDataEditorModule, AZ::SystemAllocator, 0);
+
+        SurfaceDataEditorModule();
+
+        AZ::ComponentTypeList GetRequiredSystemComponents() const override;
+    };
+}

Gems/SurfaceData/Code/Source/SurfaceDataModule.cpp

@@ -0,0 +1,49 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include "SurfaceData_precompiled.h"
+
+#include <SurfaceDataModule.h>
+#include <SurfaceDataSystemComponent.h>
+#include <Components/SurfaceDataColliderComponent.h>
+#include <Components/SurfaceDataMeshComponent.h>
+#include <Components/SurfaceDataShapeComponent.h>
+#include <TerrainSurfaceDataSystemComponent.h>
+
+namespace SurfaceData
+{
+    SurfaceDataModule::SurfaceDataModule()
+    {
+        m_descriptors.insert(m_descriptors.end(), {
+            SurfaceDataSystemComponent::CreateDescriptor(),
+            SurfaceDataColliderComponent::CreateDescriptor(),
+            SurfaceDataMeshComponent::CreateDescriptor(),
+            SurfaceDataShapeComponent::CreateDescriptor(),
+            TerrainSurfaceDataSystemComponent::CreateDescriptor(),
+        });
+    }
+
+    AZ::ComponentTypeList SurfaceDataModule::GetRequiredSystemComponents() const
+    {
+        return AZ::ComponentTypeList{
+            azrtti_typeid<SurfaceDataSystemComponent>(),
+            azrtti_typeid<TerrainSurfaceDataSystemComponent>(),
+        };
+    }
+}
+
+#if !defined(SURFACEDATA_EDITOR)
+// 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_SurfaceData, SurfaceData::SurfaceDataModule)
+#endif

Gems/SurfaceData/Code/Source/SurfaceDataModule.h

@@ -0,0 +1,31 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include "SurfaceData_precompiled.h"
+#include <AzCore/Module/Module.h>
+
+namespace SurfaceData
+{
+    class SurfaceDataModule
+        : public AZ::Module
+    {
+    public:
+        AZ_RTTI(SurfaceDataModule, "{B58B7CA8-98C9-4DC8-8607-E094989BBBE2}", AZ::Module);
+        AZ_CLASS_ALLOCATOR(SurfaceDataModule, AZ::SystemAllocator, 0);
+
+        SurfaceDataModule();
+
+        AZ::ComponentTypeList GetRequiredSystemComponents() const override;
+    };
+}

Gems/SurfaceData/Code/Source/SurfaceDataSystemComponent.cpp

@@ -0,0 +1,466 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include "SurfaceData_precompiled.h"
+
+#include <AzCore/RTTI/BehaviorContext.h>
+#include <AzCore/Serialization/SerializeContext.h>
+#include <AzCore/Serialization/EditContext.h>
+#include <AzCore/std/sort.h>
+
+#include "SurfaceDataSystemComponent.h"
+#include <SurfaceData/SurfaceDataConstants.h>
+#include <SurfaceData/SurfaceTag.h>
+#include <SurfaceData/SurfaceDataSystemNotificationBus.h>
+#include <SurfaceData/SurfaceDataProviderRequestBus.h>
+#include <SurfaceData/SurfaceDataModifierRequestBus.h>
+#include <SurfaceData/Utility/SurfaceDataUtility.h>
+
+
+namespace SurfaceData
+{
+    void SurfaceDataSystemComponent::Reflect(AZ::ReflectContext* context)
+    {
+        SurfaceTag::Reflect(context);
+
+        if (AZ::SerializeContext* serialize = azrtti_cast<AZ::SerializeContext*>(context))
+        {
+            serialize->Class<SurfaceDataSystemComponent, AZ::Component>()
+                ->Version(0)
+                ;
+
+            if (AZ::EditContext* ec = serialize->GetEditContext())
+            {
+                ec->Class<SurfaceDataSystemComponent>("Surface Data System", "Manages registration of surface data providers and forwards intersection data requests to them")
+                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                    ->Attribute(AZ::Edit::Attributes::AppearsInAddComponentMenu, AZ_CRC("System", 0xc94d118b))
+                    ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
+                    ;
+            }
+        }
+
+        if (auto behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
+        {
+            behaviorContext->Class<SurfacePoint>()
+                ->Constructor()
+                ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::Preview)
+                ->Attribute(AZ::Script::Attributes::Category, "Vegetation")
+                ->Attribute(AZ::Script::Attributes::Module, "surface_data")
+                ->Property("entityId", BehaviorValueProperty(&SurfacePoint::m_entityId))
+                ->Property("position", BehaviorValueProperty(&SurfacePoint::m_position))
+                ->Property("normal", BehaviorValueProperty(&SurfacePoint::m_normal))
+                ->Property("masks", BehaviorValueProperty(&SurfacePoint::m_masks))
+                ;
+
+            behaviorContext->Class<SurfaceDataSystemComponent>()
+                ->RequestBus("SurfaceDataSystemRequestBus")
+                ;
+
+            behaviorContext->EBus<SurfaceDataSystemRequestBus>("SurfaceDataSystemRequestBus")
+                ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::Preview)
+                ->Attribute(AZ::Script::Attributes::Category, "Vegetation")
+                ->Attribute(AZ::Script::Attributes::Module, "surface_data")
+                ->Event("GetSurfacePoints", &SurfaceDataSystemRequestBus::Events::GetSurfacePoints)
+                ;
+
+            behaviorContext->EBus<SurfaceDataSystemNotificationBus>("SurfaceDataSystemNotificationBus")
+                ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
+                ->Attribute(AZ::Script::Attributes::Category, "Vegetation")
+                ->Attribute(AZ::Script::Attributes::Module, "surface_data")
+                ->Event("OnSurfaceChanged", &SurfaceDataSystemNotificationBus::Events::OnSurfaceChanged)
+                ;
+        }
+    }
+
+    void SurfaceDataSystemComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
+    {
+        provided.push_back(AZ_CRC("SurfaceDataSystemService", 0x1d44d25f));
+    }
+
+    void SurfaceDataSystemComponent::GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible)
+    {
+        incompatible.push_back(AZ_CRC("SurfaceDataSystemService", 0x1d44d25f));
+    }
+
+    void SurfaceDataSystemComponent::GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& required)
+    {
+        (void)required;
+    }
+
+    void SurfaceDataSystemComponent::GetDependentServices(AZ::ComponentDescriptor::DependencyArrayType& dependent)
+    {
+        (void)dependent;
+    }
+
+    void SurfaceDataSystemComponent::Init()
+    {
+    }
+
+    void SurfaceDataSystemComponent::Activate()
+    {
+        SurfaceDataSystemRequestBus::Handler::BusConnect();
+    }
+
+    void SurfaceDataSystemComponent::Deactivate()
+    {
+        SurfaceDataSystemRequestBus::Handler::BusDisconnect();
+    }
+
+    SurfaceDataRegistryHandle SurfaceDataSystemComponent::RegisterSurfaceDataProvider(const SurfaceDataRegistryEntry& entry)
+    {
+        const SurfaceDataRegistryHandle handle = RegisterSurfaceDataProviderInternal(entry);
+        if (handle != InvalidSurfaceDataRegistryHandle)
+        {
+            // Send in the entry's bounds as both the old and new bounds, since a null Aabb for old bounds
+            // would cause *all* vegetation sectors to get marked as dirty.
+            SurfaceDataSystemNotificationBus::Broadcast(&SurfaceDataSystemNotificationBus::Events::OnSurfaceChanged, entry.m_entityId, entry.m_bounds, entry.m_bounds);
+        }
+        return handle;
+    }
+
+    void SurfaceDataSystemComponent::UnregisterSurfaceDataProvider(const SurfaceDataRegistryHandle& handle)
+    {
+        const SurfaceDataRegistryEntry entry = UnregisterSurfaceDataProviderInternal(handle);
+        if (entry.m_entityId.IsValid())
+        {
+            // Send in the entry's bounds as both the old and new bounds, since a null Aabb for new bounds
+            // would cause *all* vegetation sectors to get marked as dirty.
+            SurfaceDataSystemNotificationBus::Broadcast(&SurfaceDataSystemNotificationBus::Events::OnSurfaceChanged, entry.m_entityId, entry.m_bounds, entry.m_bounds);
+        }
+    }
+
+    void SurfaceDataSystemComponent::UpdateSurfaceDataProvider(const SurfaceDataRegistryHandle& handle, const SurfaceDataRegistryEntry& entry)
+    {
+        AZ::Aabb oldBounds = AZ::Aabb::CreateNull();
+
+        if (UpdateSurfaceDataProviderInternal(handle, entry, oldBounds))
+        {
+            SurfaceDataSystemNotificationBus::Broadcast(&SurfaceDataSystemNotificationBus::Events::OnSurfaceChanged, entry.m_entityId, oldBounds, entry.m_bounds);
+        }
+    }
+
+    SurfaceDataRegistryHandle SurfaceDataSystemComponent::RegisterSurfaceDataModifier(const SurfaceDataRegistryEntry& entry)
+    {
+        const SurfaceDataRegistryHandle handle = RegisterSurfaceDataModifierInternal(entry);
+        if (handle != InvalidSurfaceDataRegistryHandle)
+        {
+            // Send in the entry's bounds as both the old and new bounds, since a null Aabb for old bounds
+            // would cause *all* vegetation sectors to get marked as dirty.
+            SurfaceDataSystemNotificationBus::Broadcast(&SurfaceDataSystemNotificationBus::Events::OnSurfaceChanged, entry.m_entityId, entry.m_bounds, entry.m_bounds);
+        }
+        return handle;
+    }
+
+    void SurfaceDataSystemComponent::UnregisterSurfaceDataModifier(const SurfaceDataRegistryHandle& handle)
+    {
+        const SurfaceDataRegistryEntry entry = UnregisterSurfaceDataModifierInternal(handle);
+        if (entry.m_entityId.IsValid())
+        {
+            // Send in the entry's bounds as both the old and new bounds, since a null Aabb for new bounds
+            // would cause *all* vegetation sectors to get marked as dirty.
+            SurfaceDataSystemNotificationBus::Broadcast(&SurfaceDataSystemNotificationBus::Events::OnSurfaceChanged, entry.m_entityId, entry.m_bounds, entry.m_bounds);
+        }
+    }
+
+    void SurfaceDataSystemComponent::UpdateSurfaceDataModifier(const SurfaceDataRegistryHandle& handle, const SurfaceDataRegistryEntry& entry)
+    {
+        AZ::Aabb oldBounds = AZ::Aabb::CreateNull();
+
+        if (UpdateSurfaceDataModifierInternal(handle, entry, oldBounds))
+        {
+            SurfaceDataSystemNotificationBus::Broadcast(&SurfaceDataSystemNotificationBus::Events::OnSurfaceChanged, entry.m_entityId, oldBounds, entry.m_bounds);
+        }
+    }
+
+    void SurfaceDataSystemComponent::RefreshSurfaceData(const AZ::Aabb& dirtyBounds)
+    {
+        SurfaceDataSystemNotificationBus::Broadcast(&SurfaceDataSystemNotificationBus::Events::OnSurfaceChanged, AZ::EntityId(), dirtyBounds, dirtyBounds);
+    }
+
+    void SurfaceDataSystemComponent::GetSurfacePoints(const AZ::Vector3& inPosition, const SurfaceTagVector& desiredTags, SurfacePointList& surfacePointList) const
+    {
+        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+
+        const bool hasDesiredTags = HasValidTags(desiredTags);
+        const bool hasModifierTags = hasDesiredTags && HasMatchingTags(desiredTags, m_registeredModifierTags);
+
+        AZStd::lock_guard<decltype(m_registrationMutex)> registrationLock(m_registrationMutex);
+
+        surfacePointList.clear();
+
+        //gather all intersecting points
+        for (const auto& entryPair : m_registeredSurfaceDataProviders)
+        {
+            const AZ::u32 entryAddress = entryPair.first;
+            const SurfaceDataRegistryEntry& entry = entryPair.second;
+            AZ::Vector3 point2d(inPosition.GetX(), inPosition.GetY(), entry.m_bounds.GetMax().GetZ());
+            if (!entry.m_bounds.IsValid() || entry.m_bounds.Contains(point2d))
+            {
+                if (!hasDesiredTags || hasModifierTags || HasMatchingTags(desiredTags, entry.m_tags))
+                {
+                    SurfaceDataProviderRequestBus::Event(entryAddress, &SurfaceDataProviderRequestBus::Events::GetSurfacePoints, point2d, surfacePointList);
+                }
+            }
+        }
+
+        if (!surfacePointList.empty())
+        {
+            //modify or annotate reported points
+            for (const auto& entryPair : m_registeredSurfaceDataModifiers)
+            {
+                const AZ::u32 entryAddress = entryPair.first;
+                const SurfaceDataRegistryEntry& entry = entryPair.second;
+                AZ::Vector3 point2d(inPosition.GetX(), inPosition.GetY(), entry.m_bounds.GetMax().GetZ());
+                if (!entry.m_bounds.IsValid() || entry.m_bounds.Contains(point2d))
+                {
+                    SurfaceDataModifierRequestBus::Event(entryAddress, &SurfaceDataModifierRequestBus::Events::ModifySurfacePoints, surfacePointList);
+                }
+            }
+            
+            // After we've finished creating and annotating all the surface points, combine any points together that have effectively the
+            // same XY coordinates and extremely similar Z values.  This produces results that are sorted in decreasing Z order.
+            // Also, this filters out any remaining points that don't match the desired tag list.  This can happen when a surface provider
+            // doesn't add a desired tag, and a surface modifier has the *potential* to add it, but then doesn't.
+            CombineSortAndFilterNeighboringPoints(surfacePointList, hasDesiredTags, desiredTags);
+        }
+    }
+
+    void SurfaceDataSystemComponent::GetSurfacePointsFromRegion(const AZ::Aabb& inRegion, const AZ::Vector2 stepSize, const SurfaceTagVector& desiredTags, SurfacePointListPerPosition& surfacePointListPerPosition) const
+    {
+        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+
+        AZStd::lock_guard<decltype(m_registrationMutex)> registrationLock(m_registrationMutex);
+
+        surfacePointListPerPosition.clear();
+        surfacePointListPerPosition.reserve(aznumeric_cast<uint32_t>(ceil(inRegion.GetXExtent() / stepSize.GetX())) * aznumeric_cast<uint32_t>(ceil(inRegion.GetYExtent() / stepSize.GetY())));
+
+        // Initialize our list-per-position list with every input position to query from the region.
+        // This is inclusive on the min sides of inRegion, and exclusive on the max sides.
+        for (float y = inRegion.GetMin().GetY(); y < inRegion.GetMax().GetY(); y += stepSize.GetY())
+        {
+            for (float x = inRegion.GetMin().GetX(); x < inRegion.GetMax().GetX(); x += stepSize.GetX())
+            {
+                surfacePointListPerPosition.emplace_back(AZ::Vector3(x, y, AZ::Constants::FloatMax), SurfaceData::SurfacePointList{});
+            }
+        }
+
+        const bool hasDesiredTags = HasValidTags(desiredTags);
+        const bool hasModifierTags = hasDesiredTags && HasMatchingTags(desiredTags, m_registeredModifierTags);
+
+        // Loop through each data provider, and query all the points for each one.  This allows us to check the tags and the overall
+        // AABB bounds just once per provider, instead of once per point.  It also allows for an eventual optimization in which we could send
+        // the list of points directly into each SurfaceDataProvider.
+        for (const auto& entryPair : m_registeredSurfaceDataProviders)
+        {
+            const SurfaceDataRegistryEntry& entry = entryPair.second;
+            bool alwaysApplies = !entry.m_bounds.IsValid();
+
+            if ((!hasDesiredTags || hasModifierTags || HasMatchingTags(desiredTags, entry.m_tags)) &&
+                ( alwaysApplies || AabbOverlaps2D(entry.m_bounds, inRegion) )
+                )
+            {
+                for (auto& surfacePointListAndPoint : surfacePointListPerPosition)
+                {
+                    const auto& point2d = surfacePointListAndPoint.first;
+                    SurfacePointList& surfacePointList = surfacePointListAndPoint.second;
+                    AZ::Vector3 point3d(point2d.GetX(), point2d.GetY(), entry.m_bounds.GetMax().GetZ());
+                    if (alwaysApplies || entry.m_bounds.Contains(point3d))
+                    {
+                        SurfaceDataProviderRequestBus::Event(entryPair.first, &SurfaceDataProviderRequestBus::Events::GetSurfacePoints, point3d, surfacePointList);
+                    }
+                }
+            }
+        }
+
+        // Once we have our list of surface points created, run through the list of surface data modifiers to potentially add
+        // surface tags / values onto each point.  The difference between this and the above loop is that surface data *providers*
+        // create new surface points, but surface data *modifiers* simply annotate points that have already been created.  The modifiers
+        // are used to annotate points that occur within a volume.  A common example is marking points as "underwater" for points that occur
+        // within a water volume.
+        for (const auto& entryPair : m_registeredSurfaceDataModifiers)
+        {
+            const SurfaceDataRegistryEntry& entry = entryPair.second;
+            bool alwaysApplies = !entry.m_bounds.IsValid();
+
+            if (alwaysApplies || AabbOverlaps2D(entry.m_bounds, inRegion))
+            {
+                for (auto& surfacePointListAndPoint : surfacePointListPerPosition)
+                {
+                    const auto& point2d = surfacePointListAndPoint.first;
+                    SurfacePointList& surfacePointList = surfacePointListAndPoint.second;
+                    if (!surfacePointList.empty())
+                    {
+                        AZ::Vector3 point3d(point2d.GetX(), point2d.GetY(), entry.m_bounds.GetMax().GetZ());
+                        if (alwaysApplies || entry.m_bounds.Contains(point3d))
+                        {
+                            SurfaceDataModifierRequestBus::Event(entryPair.first, &SurfaceDataModifierRequestBus::Events::ModifySurfacePoints, surfacePointList);
+                        }
+                    }
+                }
+            }
+        }
+
+        // After we've finished creating and annotating all the surface points, combine any points together that have effectively the
+        // same XY coordinates and extremely similar Z values.  This produces results that are sorted in decreasing Z order.
+        // Also, this filters out any remaining points that don't match the desired tag list.  This can happen when a surface provider
+        // doesn't add a desired tag, and a surface modifier has the *potential* to add it, but then doesn't.
+        for (auto& surfacePointListAndPoint : surfacePointListPerPosition)
+        {
+            auto& surfacePointList = surfacePointListAndPoint.second;
+            if (!surfacePointList.empty())
+            {
+                CombineSortAndFilterNeighboringPoints(surfacePointList, hasDesiredTags, desiredTags);
+            }
+        }
+    }
+
+    void SurfaceDataSystemComponent::CombineSortAndFilterNeighboringPoints(SurfacePointList& sourcePointList, bool hasDesiredTags, const SurfaceTagVector& desiredTags) const
+    {
+        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+
+        if (sourcePointList.empty())
+        {
+            return;
+        }
+
+        // Sorting only makes sense if we have two or more points
+        if (sourcePointList.size() > 1)
+        {
+            //sort by depth/distance before combining points
+            AZStd::sort(sourcePointList.begin(), sourcePointList.end(), [](const SurfacePoint& a, const SurfacePoint& b)
+            {
+                return a.m_position.GetZ() > b.m_position.GetZ();
+            });
+        }
+
+
+        //efficient point consolidation requires the points to be pre-sorted so we are only comparing/combining neighbors
+        const size_t sourcePointCount = sourcePointList.size();
+        size_t targetPointIndex = 0;
+        size_t sourcePointIndex = 0;
+
+        m_targetPointList.clear();
+        m_targetPointList.reserve(sourcePointCount);
+
+        // Locate the first point that matches our desired tags, if one exists.
+        for (sourcePointIndex = 0; sourcePointIndex < sourcePointCount; sourcePointIndex++)
+        {
+            if (!hasDesiredTags || (HasMatchingTags(sourcePointList[sourcePointIndex].m_masks, desiredTags)))
+            {
+                break;
+            }
+        }
+
+        if (sourcePointIndex < sourcePointCount)
+        {
+            // We found a point that matches our tags, so add it to our target list as the first point.
+            m_targetPointList.push_back(sourcePointList[sourcePointIndex++]);
+
+            //iterate over subsequent source points for comparison and consolidation with the last added target/unique point
+            for (; sourcePointIndex < sourcePointCount; ++sourcePointIndex)
+            {
+                const auto& sourcePoint = sourcePointList[sourcePointIndex];
+
+                if (!hasDesiredTags || (HasMatchingTags(sourcePoint.m_masks, desiredTags)))
+                {
+                    auto& targetPoint = m_targetPointList[targetPointIndex];
+
+                    // [LY-90907] need to add a configurable tolerance for comparison
+                    if (targetPoint.m_position.IsClose(sourcePoint.m_position) &&
+                        targetPoint.m_normal.IsClose(sourcePoint.m_normal))
+                    {
+                        //consolidate points with similar attributes by adding masks to the target point and ignoring the source
+                        AddMaxValueForMasks(targetPoint.m_masks, sourcePoint.m_masks);
+                        continue;
+                    }
+
+                    //if the points were too different, we have to add a new target point to compare against
+                    m_targetPointList.push_back(sourcePoint);
+                    ++targetPointIndex;
+                }
+            }
+
+            AZStd::swap(sourcePointList, m_targetPointList);
+        }
+    }
+
+    SurfaceDataRegistryHandle SurfaceDataSystemComponent::RegisterSurfaceDataProviderInternal(const SurfaceDataRegistryEntry& entry)
+    {
+        AZStd::lock_guard<decltype(m_registrationMutex)> registrationLock(m_registrationMutex);
+        SurfaceDataRegistryHandle handle = ++m_registeredSurfaceDataProviderHandleCounter;
+        m_registeredSurfaceDataProviders[handle] = entry;
+        return handle;
+    }
+
+    SurfaceDataRegistryEntry SurfaceDataSystemComponent::UnregisterSurfaceDataProviderInternal(const SurfaceDataRegistryHandle& handle)
+    {
+        AZStd::lock_guard<decltype(m_registrationMutex)> registrationLock(m_registrationMutex);
+        SurfaceDataRegistryEntry entry;
+        auto entryItr = m_registeredSurfaceDataProviders.find(handle);
+        if (entryItr != m_registeredSurfaceDataProviders.end())
+        {
+            entry = entryItr->second;
+            m_registeredSurfaceDataProviders.erase(entryItr);
+        }
+        return entry;
+    }
+
+    bool SurfaceDataSystemComponent::UpdateSurfaceDataProviderInternal(const SurfaceDataRegistryHandle& handle, const SurfaceDataRegistryEntry& entry, AZ::Aabb& oldBounds)
+    {
+        AZStd::lock_guard<decltype(m_registrationMutex)> registrationLock(m_registrationMutex);
+        auto entryItr = m_registeredSurfaceDataProviders.find(handle);
+        if (entryItr != m_registeredSurfaceDataProviders.end())
+        {
+            oldBounds = entryItr->second.m_bounds;
+            entryItr->second = entry;
+            return true;
+        }
+        return false;
+    }
+
+    SurfaceDataRegistryHandle SurfaceDataSystemComponent::RegisterSurfaceDataModifierInternal(const SurfaceDataRegistryEntry& entry)
+    {
+        AZStd::lock_guard<decltype(m_registrationMutex)> registrationLock(m_registrationMutex);
+        SurfaceDataRegistryHandle handle = ++m_registeredSurfaceDataModifierHandleCounter;
+        m_registeredSurfaceDataModifiers[handle] = entry;
+        m_registeredModifierTags.insert(entry.m_tags.begin(), entry.m_tags.end());
+        return handle;
+    }
+
+    SurfaceDataRegistryEntry SurfaceDataSystemComponent::UnregisterSurfaceDataModifierInternal(const SurfaceDataRegistryHandle& handle)
+    {
+        AZStd::lock_guard<decltype(m_registrationMutex)> registrationLock(m_registrationMutex);
+        SurfaceDataRegistryEntry entry;
+        auto entryItr = m_registeredSurfaceDataModifiers.find(handle);
+        if (entryItr != m_registeredSurfaceDataModifiers.end())
+        {
+            entry = entryItr->second;
+            m_registeredSurfaceDataModifiers.erase(entryItr);
+        }
+        return entry;
+    }
+
+    bool SurfaceDataSystemComponent::UpdateSurfaceDataModifierInternal(const SurfaceDataRegistryHandle& handle, const SurfaceDataRegistryEntry& entry, AZ::Aabb& oldBounds)
+    {
+        AZStd::lock_guard<decltype(m_registrationMutex)> registrationLock(m_registrationMutex);
+        auto entryItr = m_registeredSurfaceDataModifiers.find(handle);
+        if (entryItr != m_registeredSurfaceDataModifiers.end())
+        {
+            oldBounds = entryItr->second.m_bounds;
+            entryItr->second = entry;
+            m_registeredModifierTags.insert(entry.m_tags.begin(), entry.m_tags.end());
+            return true;
+        }
+        return false;
+    }
+
+}

Gems/SurfaceData/Code/Source/SurfaceDataSystemComponent.h

@@ -0,0 +1,78 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <AzCore/Component/Component.h>
+#include <AzCore/Math/Aabb.h>
+#include <SurfaceData/SurfaceDataSystemRequestBus.h>
+
+namespace SurfaceData
+{
+    class SurfaceDataSystemComponent
+        : public AZ::Component
+        , private SurfaceDataSystemRequestBus::Handler
+    {
+    public:
+        AZ_COMPONENT(SurfaceDataSystemComponent, "{6F334BAA-7BD5-45F8-A9BA-760667D25FA0}");
+
+        static void Reflect(AZ::ReflectContext* context);
+
+        static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided);
+        static void GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible);
+        static void GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& required);
+        static void GetDependentServices(AZ::ComponentDescriptor::DependencyArrayType& dependent);
+
+    protected:
+        ////////////////////////////////////////////////////////////////////////
+        // AZ::Component interface implementation
+        void Init() override;
+        void Activate() override;
+        void Deactivate() override;
+        
+        
+        ////////////////////////////////////////////////////////////////////////
+        // SurfaceDataSystemRequestBus implementation
+        void GetSurfacePoints(const AZ::Vector3& inPosition, const SurfaceTagVector& desiredTags, SurfacePointList& surfacePointList) const override;
+        void GetSurfacePointsFromRegion(const AZ::Aabb& inRegion, const AZ::Vector2 stepSize, const SurfaceTagVector& desiredTags, SurfacePointListPerPosition& surfacePointListPerPosition) const override;
+
+        SurfaceDataRegistryHandle RegisterSurfaceDataProvider(const SurfaceDataRegistryEntry& entry) override;
+        void UnregisterSurfaceDataProvider(const SurfaceDataRegistryHandle& handle) override;
+        void UpdateSurfaceDataProvider(const SurfaceDataRegistryHandle& handle, const SurfaceDataRegistryEntry& entry) override;
+
+        SurfaceDataRegistryHandle RegisterSurfaceDataModifier(const SurfaceDataRegistryEntry& entry) override;
+        void UnregisterSurfaceDataModifier(const SurfaceDataRegistryHandle& handle) override;
+        void UpdateSurfaceDataModifier(const SurfaceDataRegistryHandle& handle, const SurfaceDataRegistryEntry& entry) override;
+
+        void RefreshSurfaceData(const AZ::Aabb& dirtyArea) override;
+    private:
+        void CombineSortAndFilterNeighboringPoints(SurfacePointList& sourcePointList, bool hasDesiredTags, const SurfaceTagVector& desiredTags) const;
+
+        SurfaceDataRegistryHandle RegisterSurfaceDataProviderInternal(const SurfaceDataRegistryEntry& entry);
+        SurfaceDataRegistryEntry UnregisterSurfaceDataProviderInternal(const SurfaceDataRegistryHandle& handle);
+        bool UpdateSurfaceDataProviderInternal(const SurfaceDataRegistryHandle& handle, const SurfaceDataRegistryEntry& entry, AZ::Aabb& oldBounds);
+
+        SurfaceDataRegistryHandle RegisterSurfaceDataModifierInternal(const SurfaceDataRegistryEntry& entry);
+        SurfaceDataRegistryEntry UnregisterSurfaceDataModifierInternal(const SurfaceDataRegistryHandle& handle);
+        bool UpdateSurfaceDataModifierInternal(const SurfaceDataRegistryHandle& handle, const SurfaceDataRegistryEntry& entry, AZ::Aabb& oldBounds);
+
+        mutable AZStd::recursive_mutex m_registrationMutex;
+        AZStd::unordered_map<SurfaceDataRegistryHandle, SurfaceDataRegistryEntry> m_registeredSurfaceDataProviders;
+        AZStd::unordered_map<SurfaceDataRegistryHandle, SurfaceDataRegistryEntry> m_registeredSurfaceDataModifiers;
+        SurfaceDataRegistryHandle m_registeredSurfaceDataProviderHandleCounter = InvalidSurfaceDataRegistryHandle;
+        SurfaceDataRegistryHandle m_registeredSurfaceDataModifierHandleCounter = InvalidSurfaceDataRegistryHandle;
+        AZStd::unordered_set<AZ::u32> m_registeredModifierTags;
+
+        //point vector reserved for reuse
+        mutable SurfacePointList m_targetPointList;
+    };
+}

Gems/SurfaceData/Code/Source/SurfaceData_precompiled.cpp

@@ -0,0 +1,12 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+#include "SurfaceData_precompiled.h"

Gems/SurfaceData/Code/Source/SurfaceData_precompiled.h

@@ -0,0 +1,14 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+#pragma once
+
+#include <platform.h> // Many CryCommon files require that this is included first.

Gems/SurfaceData/Code/Source/SurfaceTag.cpp

@@ -0,0 +1,167 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include "SurfaceData_precompiled.h"
+#include <SurfaceData/SurfaceTag.h>
+
+#include <AzCore/RTTI/BehaviorContext.h>
+#include <AzCore/Serialization/EditContext.h>
+#include <AzCore/Serialization/SerializeContext.h>
+#include <SurfaceData/SurfaceDataTagProviderRequestBus.h>
+#include <AzCore/Debug/Profiler.h>
+#include <AzCore/std/sort.h>
+
+namespace SurfaceData
+{
+    namespace SurfaceTagUtil
+    {
+        static bool UpdateVersion(AZ::SerializeContext& context, AZ::SerializeContext::DataElementNode& classElement)
+        {
+            if (classElement.GetVersion() < 1)
+            {
+                AZStd::string surfaceTag;
+                if (classElement.GetChildData(AZ_CRC("SurfaceTag", 0xafd98787), surfaceTag))
+                {
+                    classElement.RemoveElementByName(AZ_CRC("SurfaceTag", 0xafd98787));
+                    classElement.AddElementWithData(context, "SurfaceTagCrc", (AZ::u32)(AZ::Crc32(surfaceTag.data())));
+                }
+            }
+            if (classElement.GetVersion() < 2)
+            {
+                SurfaceTag surfaceTag;
+                if (classElement.GetData(surfaceTag))
+                {
+                    if (surfaceTag == AZ_CRC("(default)", 0x3c3d0dd8))
+                    {
+                        surfaceTag = Constants::s_unassignedTagCrc;
+                        classElement.SetData(context, surfaceTag);
+                    }
+                }
+            }
+            return true;
+        }
+    }
+
+    void SurfaceTag::Reflect(AZ::ReflectContext* context)
+    {
+        AZ::SerializeContext* serialize = azrtti_cast<AZ::SerializeContext*>(context);
+        if (serialize)
+        {
+            serialize->Class<SurfaceTag>()
+                ->Version(2, &SurfaceTagUtil::UpdateVersion)
+                ->Field("SurfaceTagCrc", &SurfaceTag::m_surfaceTagCrc)
+                ;
+
+            AZ::EditContext* edit = serialize->GetEditContext();
+            if (edit)
+            {
+                edit->Class<SurfaceTag>(
+                    "Surface Tag", "Matches a surface value like a mask or material")
+                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                    ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
+                    ->Attribute(AZ::Edit::Attributes::Visibility, AZ::Edit::PropertyVisibility::ShowChildrenOnly)
+                    ->DataElement(AZ::Edit::UIHandlers::ComboBox, &SurfaceTag::m_surfaceTagCrc, "Surface Tag", "Matches a surface value like a mask or material")
+                    ->Attribute(AZ::Edit::Attributes::EnumValues, &SurfaceTag::BuildSelectableTagList)
+                    ->Attribute(AZ::Edit::Attributes::ChangeNotify, AZ::Edit::PropertyRefreshLevels::AttributesAndValues)
+                    ;
+            }
+        }
+
+        if (auto behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
+        {
+            behaviorContext->Class<SurfaceTag>()
+                ->Constructor()
+                ->Constructor<const AZStd::string&>()
+                ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
+                ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::Preview)
+                ->Attribute(AZ::Script::Attributes::Category, "Vegetation")
+                ->Attribute(AZ::Script::Attributes::Module, "surface_data")
+                ->Method("SetTag", &SurfaceTag::SetTag)
+                ->Method("Equal", &SurfaceTag::operator==)
+                ->Attribute(AZ::Script::Attributes::Operator, AZ::Script::Attributes::OperatorType::Equal)
+                ;
+        }
+    }
+
+    AZStd::vector<AZStd::pair<AZ::u32, AZStd::string>> SurfaceTag::GetRegisteredTags()
+    {
+        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+
+        SurfaceTagNameSet labels;
+        SurfaceDataTagProviderRequestBus::Broadcast(&SurfaceDataTagProviderRequestBus::Events::GetRegisteredSurfaceTagNames, labels);
+        labels.insert(Constants::s_unassignedTagName);
+
+        AZStd::vector<AZStd::pair<AZ::u32, AZStd::string>> registeredTags;
+        registeredTags.reserve(labels.size());
+        for (const auto& label : labels)
+        {
+            const AZ::u32 crc = AZ::Crc32(label.data());
+
+            //warn when two tags have the same crc
+            auto entryItr = AZStd::find_if(registeredTags.begin(), registeredTags.end(), [crc](const auto& entry) {return entry.first == crc;});
+            if (entryItr != registeredTags.end())
+            {
+                AZ_Warning("SurfaceData", false, "SurfaceTag CRC collision between \"%s\" and \"%s\"!  \"%s\" not added.", entryItr->second.data(), label.data(), label.data());
+                continue;
+            }
+
+            registeredTags.push_back({ crc, label });
+        }
+
+        return registeredTags;
+    }
+
+    bool SurfaceTag::FindDisplayName(const AZStd::vector<AZStd::pair<AZ::u32, AZStd::string>>& selectableTags, AZStd::string& name) const
+    {
+        auto it = AZStd::find_if(
+            selectableTags.begin(),
+            selectableTags.end(),
+            [this](const auto& entry) {return m_surfaceTagCrc == entry.first; });
+
+        if (it == selectableTags.end())
+        {
+            //if a match was not found, generate a name using the crc
+            name = AZStd::string::format("(unregistered %u)", m_surfaceTagCrc);
+            return false;
+        }
+
+        name = it->second;
+        return true;
+    }
+
+    AZStd::vector<AZStd::pair<AZ::u32, AZStd::string>> SurfaceTag::BuildSelectableTagList() const
+    {
+        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+
+        AZStd::vector<AZStd::pair<AZ::u32, AZStd::string>> selectableTags = GetRegisteredTags();
+
+        AZStd::string name;
+        if (!FindDisplayName(selectableTags, name))
+        {
+            //if a match was not found, add the generated name to the selectable set
+            selectableTags.push_back({ m_surfaceTagCrc, name });
+            AZ_Warning("SurfaceData", false, "SurfaceTag CRC %u is not a registered tag.", m_surfaceTagCrc);
+        }
+
+        AZStd::sort(selectableTags.begin(), selectableTags.end(), [](const auto& lhs, const auto& rhs) {return lhs.second < rhs.second;});
+        return selectableTags;
+    }
+
+    AZStd::string SurfaceTag::GetDisplayName() const
+    {
+        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::Entity);
+
+        AZStd::string name;
+        FindDisplayName(GetRegisteredTags(), name);
+        return name;
+    }
+}

Gems/SurfaceData/Code/Source/TerrainSurfaceDataSystemComponent.cpp

@@ -0,0 +1,267 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+#include "SurfaceData_precompiled.h"
+#include "TerrainSurfaceDataSystemComponent.h"
+#include <AzCore/Debug/Profiler.h> 
+#include <AzCore/Math/MathUtils.h>
+#include <AzCore/Serialization/EditContext.h>
+#include <AzCore/Serialization/SerializeContext.h>
+#include <AzFramework/Terrain/TerrainDataRequestBus.h>
+#include <MathConversion.h>
+#include <SurfaceData/SurfaceDataSystemRequestBus.h>
+#include <SurfaceData/SurfaceTag.h>
+#include <SurfaceData/Utility/SurfaceDataUtility.h>
+
+#include <ISystem.h>
+#include <I3DEngine.h>
+
+namespace SurfaceData
+{
+    //////////////////////////////////////////////////////////////////////////
+    // TerrainSurfaceDataSystemConfig
+
+    void TerrainSurfaceDataSystemConfig::Reflect(AZ::ReflectContext* context)
+    {
+        if (AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
+        {
+            serializeContext->Class<TerrainSurfaceDataSystemConfig, AZ::ComponentConfig>()
+                ->Version(0)
+                ;
+
+            if (AZ::EditContext* editContext = serializeContext->GetEditContext())
+            {
+                editContext->Class<TerrainSurfaceDataSystemConfig>(
+                    "Terrain Surface Data System", "Configures management of surface data requests against legacy terrain")
+                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                    ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
+                    ;
+            }
+        }
+    }
+
+    //////////////////////////////////////////////////////////////////////////
+    // TerrainSurfaceDataSystemComponent
+    void TerrainSurfaceDataSystemComponent::Reflect(AZ::ReflectContext* context)
+    {
+        TerrainSurfaceDataSystemConfig::Reflect(context);
+
+        AZ::SerializeContext* serialize = azrtti_cast<AZ::SerializeContext*>(context);
+        if (serialize)
+        {
+            serialize->Class<TerrainSurfaceDataSystemComponent, AZ::Component>()
+                ->Version(0)
+                ->Field("Configuration", &TerrainSurfaceDataSystemComponent::m_configuration)
+                ;
+
+            if (AZ::EditContext* editContext = serialize->GetEditContext())
+            {
+                editContext->Class<TerrainSurfaceDataSystemComponent>("Terrain Surface Data System", "Manages surface data requests against legacy terrain")
+                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                    ->Attribute(AZ::Edit::Attributes::Category, "Surface Data")
+                    ->Attribute(AZ::Edit::Attributes::AppearsInAddComponentMenu, AZ_CRC("System", 0xc94d118b))
+                    ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
+                    ->DataElement(0, &TerrainSurfaceDataSystemComponent::m_configuration, "Configuration", "")
+                    ->Attribute(AZ::Edit::Attributes::Visibility, AZ::Edit::PropertyVisibility::ShowChildrenOnly)
+                    ;
+            }
+        }
+    }
+
+    TerrainSurfaceDataSystemComponent::TerrainSurfaceDataSystemComponent(const TerrainSurfaceDataSystemConfig& configuration)
+        : m_configuration(configuration)
+    {
+    }
+
+    TerrainSurfaceDataSystemComponent::TerrainSurfaceDataSystemComponent()
+    {
+    }
+
+    void TerrainSurfaceDataSystemComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& services)
+    {
+        services.push_back(AZ_CRC("SurfaceDataProviderService", 0xfe9fb95e));
+        services.push_back(AZ_CRC("TerrainSurfaceDataProviderService", 0xa1ac7717));
+    }
+
+    void TerrainSurfaceDataSystemComponent::GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& services)
+    {
+        services.push_back(AZ_CRC("TerrainSurfaceDataProviderService", 0xa1ac7717));
+    }
+
+    void TerrainSurfaceDataSystemComponent::GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& services)
+    {
+        services.push_back(AZ_CRC("SurfaceDataSystemService", 0x1d44d25f));
+    }
+
+    void TerrainSurfaceDataSystemComponent::Activate()
+    {
+        m_providerHandle = InvalidSurfaceDataRegistryHandle;
+        m_system = GetISystem();
+        CrySystemEventBus::Handler::BusConnect();
+        AZ::HeightmapUpdateNotificationBus::Handler::BusConnect();
+
+        UpdateTerrainData(AZ::Aabb::CreateNull());
+    }
+
+    void TerrainSurfaceDataSystemComponent::Deactivate()
+    {
+        if (m_providerHandle != InvalidSurfaceDataRegistryHandle)
+        {
+            SurfaceDataSystemRequestBus::Broadcast(&SurfaceDataSystemRequestBus::Events::UnregisterSurfaceDataProvider, m_providerHandle);
+            m_providerHandle = InvalidSurfaceDataRegistryHandle;
+        }
+
+        SurfaceDataProviderRequestBus::Handler::BusDisconnect();
+        AZ::HeightmapUpdateNotificationBus::Handler::BusDisconnect();
+        CrySystemEventBus::Handler::BusDisconnect();
+        m_system = nullptr;
+
+        // Clear the cached terrain bounds data
+        {
+            m_terrainBounds = AZ::Aabb::CreateNull();
+            m_terrainBoundsIsValid = false;
+        }
+    }
+
+    bool TerrainSurfaceDataSystemComponent::ReadInConfig(const AZ::ComponentConfig* baseConfig)
+    {
+        if (const auto config = azrtti_cast<const TerrainSurfaceDataSystemConfig*>(baseConfig))
+        {
+            m_configuration = *config;
+            return true;
+        }
+        return false;
+    }
+
+    bool TerrainSurfaceDataSystemComponent::WriteOutConfig(AZ::ComponentConfig* outBaseConfig) const
+    {
+        if (auto config = azrtti_cast<TerrainSurfaceDataSystemConfig*>(outBaseConfig))
+        {
+            *config = m_configuration;
+            return true;
+        }
+        return false;
+    }
+
+    void TerrainSurfaceDataSystemComponent::OnCrySystemInitialized(ISystem& system, [[maybe_unused]] const SSystemInitParams& systemInitParams)
+    {
+        m_system = &system;
+    }
+
+    void TerrainSurfaceDataSystemComponent::OnCrySystemShutdown([[maybe_unused]] ISystem& system)
+    {
+        m_system = nullptr;
+    }
+
+    void TerrainSurfaceDataSystemComponent::GetSurfacePoints(const AZ::Vector3& inPosition, SurfacePointList& surfacePointList) const
+    {
+        if (m_terrainBoundsIsValid)
+        {
+            auto enumerationCallback = [&](AzFramework::Terrain::TerrainDataRequests* terrain) -> bool
+            {
+                if (terrain->GetTerrainAabb().Contains(inPosition))
+                {
+                    bool isTerrainValidAtPoint = false;
+                    const float terrainHeight = terrain->GetHeight(inPosition, AzFramework::Terrain::TerrainDataRequests::Sampler::BILINEAR, &isTerrainValidAtPoint);
+                    const bool isHole = !isTerrainValidAtPoint;
+
+                    SurfacePoint point;
+                    point.m_entityId = GetEntityId();
+                    point.m_position = AZ::Vector3(inPosition.GetX(), inPosition.GetY(), terrainHeight);
+                    point.m_normal = terrain->GetNormal(inPosition);
+                    const AZ::Crc32 terrainTag = isHole ? Constants::s_terrainHoleTagCrc : Constants::s_terrainTagCrc;
+                    AddMaxValueForMasks(point.m_masks, terrainTag, 1.0f);
+                    surfacePointList.push_back(point);
+                }
+                // Only one handler should exist.
+                return false;
+            };
+            AzFramework::Terrain::TerrainDataRequestBus::EnumerateHandlers(enumerationCallback);
+        }
+    }
+
+    AZ::Aabb TerrainSurfaceDataSystemComponent::GetSurfaceAabb() const
+    {
+        auto terrain = AzFramework::Terrain::TerrainDataRequestBus::FindFirstHandler();
+        return terrain ? terrain->GetTerrainAabb() : AZ::Aabb::CreateNull();
+    }
+
+    SurfaceTagVector TerrainSurfaceDataSystemComponent::GetSurfaceTags() const
+    {
+        SurfaceTagVector tags;
+        tags.push_back(Constants::s_terrainHoleTagCrc);
+        tags.push_back(Constants::s_terrainTagCrc);
+        return tags;
+    }
+
+    void TerrainSurfaceDataSystemComponent::UpdateTerrainData(const AZ::Aabb& dirtyRegion)
+    {
+        bool terrainValidBeforeUpdate = m_terrainBoundsIsValid;
+        bool terrainValidAfterUpdate = false;
+        AZ::Aabb terrainBoundsBeforeUpdate = m_terrainBounds;
+
+        SurfaceDataRegistryEntry registryEntry;
+        registryEntry.m_entityId = GetEntityId();
+        registryEntry.m_bounds = GetSurfaceAabb();
+        registryEntry.m_tags = GetSurfaceTags();
+
+        m_terrainBounds = registryEntry.m_bounds;
+        m_terrainBoundsIsValid = m_terrainBounds.IsValid();
+
+        terrainValidAfterUpdate = m_terrainBoundsIsValid;
+
+        if (terrainValidBeforeUpdate && terrainValidAfterUpdate)
+        {
+            AZ_Assert((m_providerHandle != InvalidSurfaceDataRegistryHandle), "Invalid surface data handle");
+
+            // Our terrain was valid before and after, it just changed in some way.  If we have a valid dirty region passed in
+            // then it's possible that the heightmap has been modified in the Editor.  Otherwise, just notify that the entire
+            // terrain has changed in some way.
+            if (dirtyRegion.IsValid())
+            {
+                SurfaceDataSystemRequestBus::Broadcast(&SurfaceDataSystemRequestBus::Events::RefreshSurfaceData, dirtyRegion);
+            }
+            else
+            {
+                SurfaceDataSystemRequestBus::Broadcast(&SurfaceDataSystemRequestBus::Events::UpdateSurfaceDataProvider, m_providerHandle, registryEntry);
+            }
+        }
+        else if (!terrainValidBeforeUpdate && terrainValidAfterUpdate)
+        {
+            // Our terrain has become valid, so register as a provider and save off the registry handles
+            AZ_Assert((m_providerHandle == InvalidSurfaceDataRegistryHandle), "Surface Provider data handle is initialized before our terrain became valid");
+            SurfaceDataSystemRequestBus::BroadcastResult(m_providerHandle, &SurfaceDataSystemRequestBus::Events::RegisterSurfaceDataProvider, registryEntry);
+
+            // Start listening for surface data events
+            AZ_Assert((m_providerHandle != InvalidSurfaceDataRegistryHandle), "Invalid surface data handle");
+            SurfaceDataProviderRequestBus::Handler::BusConnect(m_providerHandle);
+        }
+        else if (terrainValidBeforeUpdate && !terrainValidAfterUpdate)
+        {
+            // Our terrain has stopped being valid, so unregister and stop listening for surface data events
+            AZ_Assert((m_providerHandle != InvalidSurfaceDataRegistryHandle), "Invalid surface data handle");
+            SurfaceDataSystemRequestBus::Broadcast(&SurfaceDataSystemRequestBus::Events::UnregisterSurfaceDataProvider, m_providerHandle);
+            m_providerHandle = InvalidSurfaceDataRegistryHandle;
+
+            SurfaceDataProviderRequestBus::Handler::BusDisconnect();
+        }
+        else
+        {
+            // We didn't have a valid terrain before or after running this, so do nothing.
+        }
+
+    }
+
+    void TerrainSurfaceDataSystemComponent::HeightmapModified(const AZ::Aabb& bounds)
+    {
+        UpdateTerrainData(bounds);
+    }
+}

Gems/SurfaceData/Code/Source/TerrainSurfaceDataSystemComponent.h

@@ -0,0 +1,88 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+#pragma once
+
+#include <AzCore/Component/Component.h>
+#include <AzCore/Component/Entity.h>
+#include <AzCore/EBus/EBus.h>
+#include <CrySystemBus.h>
+#include <HeightmapUpdateNotificationBus.h>
+#include <SurfaceData/SurfaceDataModifierRequestBus.h>
+#include <SurfaceData/SurfaceDataProviderRequestBus.h>
+
+namespace SurfaceData
+{
+    class TerrainSurfaceDataSystemConfig
+        : public AZ::ComponentConfig
+    {
+    public:
+        AZ_CLASS_ALLOCATOR(TerrainSurfaceDataSystemConfig, AZ::SystemAllocator, 0);
+        AZ_RTTI(TerrainSurfaceDataSystemConfig, "{2B93F5E5-5346-47A1-9C4D-EFBC6BDF468F}", AZ::ComponentConfig);
+        static void Reflect(AZ::ReflectContext* context);
+    };
+
+    /**
+    * The system component to serve for the game side queries for surface values
+    */
+    class TerrainSurfaceDataSystemComponent
+        : public AZ::Component
+        , private SurfaceDataProviderRequestBus::Handler
+        , private AZ::HeightmapUpdateNotificationBus::Handler
+        , private CrySystemEventBus::Handler
+    {
+        friend class EditorTerrainSurfaceDataSystemComponent;
+        TerrainSurfaceDataSystemComponent(const TerrainSurfaceDataSystemConfig&);
+
+    public:
+        TerrainSurfaceDataSystemComponent();
+
+        //////////////////////////////////////////////////////////////////////////
+        // Component static
+        AZ_COMPONENT(TerrainSurfaceDataSystemComponent, "{0C821DA4-6DB1-4860-BE25-CB57B3E3F4D4}", AZ::Component);
+        static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& services);
+        static void GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& services);
+        static void GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& services);
+        static void Reflect(AZ::ReflectContext* context);
+
+        //////////////////////////////////////////////////////////////////////////
+        // Component
+        void Activate() override;
+        void Deactivate() override;
+        bool ReadInConfig(const AZ::ComponentConfig* baseConfig) override;
+        bool WriteOutConfig(AZ::ComponentConfig* outBaseConfig) const override;
+
+        //////////////////////////////////////////////////////////////////////////
+        // SurfaceDataProviderRequestBus
+        void GetSurfacePoints(const AZ::Vector3& inPosition, SurfacePointList& surfacePointList) const;
+
+        ////////////////////////////////////////////////////////////////////////////
+        // CrySystemEvents
+        void OnCrySystemInitialized(ISystem& system, const SSystemInitParams& systemInitParams) override;
+        void OnCrySystemShutdown(ISystem& system) override;
+
+        //////////////////////////////////////////////////////////////////////////
+        // AZ::HeightmapUpdateNotificationBus
+        void HeightmapModified(const AZ::Aabb& bounds) override;
+
+    private:
+        void UpdateTerrainData(const AZ::Aabb& dirtyRegion);
+        AZ::Aabb GetSurfaceAabb() const;
+        SurfaceTagVector GetSurfaceTags() const;
+        SurfaceDataRegistryHandle m_providerHandle = InvalidSurfaceDataRegistryHandle;
+
+        TerrainSurfaceDataSystemConfig m_configuration;
+        ISystem* m_system = nullptr;
+
+        AZ::Aabb m_terrainBounds = AZ::Aabb::CreateNull();
+        AZStd::atomic_bool m_terrainBoundsIsValid{ false };
+    };
+}