LYN-8403 Prevent the same Surface Tag from getting reused

Signed-off-by: Sergey Pereslavtsev <pereslav@amazon.com>

Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyEditorAPI_Internals.h

@@ -154,6 +154,16 @@ namespace AzToolsFramework
             (void)debugName;
         }
 
+        // provides an option to specify reading parent element attributes.
+        // This allows parent elements to override attributes of their children if needed.
+        virtual void ConsumeParentAttribute(WidgetType* widget, AZ::u32 attrib, PropertyAttributeReader* attrValue, const char* debugName)
+        {
+            (void)widget;
+            (void)attrib;
+            (void)attrValue;
+            (void)debugName;
+        }
+
         // override GetFirstInTabOrder, GetLastInTabOrder in your base class to define which widget gets focus first when pressing tab,
         // and also what widget is last.
         // for example, if your widget is a compound widget and contains, say, 5 buttons

Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyEditorAPI_Internals_Impl.h

@@ -40,7 +40,14 @@ namespace AzToolsFramework
         }
 
         void* classInstance = parent->FirstInstance(); // pointer to the owner class so we can read member variables and functions
-        auto consumeAttributes = [&](const auto& attributes, const char* name)
+
+        void* parentClassInstance = nullptr;
+        if (InstanceDataNode* parentInstanceDataNode = parent->GetParent())
+        {
+            parentClassInstance = parentInstanceDataNode->FirstInstance();
+        }
+
+        auto consumeAttributes = [this, classInstance, wid](const auto& attributes, const char* name)
         {
             for (size_t i = 0; i < attributes.size(); ++i)
             {
@@ -50,25 +57,43 @@ namespace AzToolsFramework
             }
         };
 
+        auto consumeParentAttributes = [this, parentClassInstance, wid](const auto& attributes, const char* name)
+        {
+            if (parentClassInstance)
+            {
+                for (size_t i = 0; i < attributes.size(); ++i)
+                {
+                    const auto& attrPair = attributes[i];
+                    PropertyAttributeReader reader(parentClassInstance, &*attrPair.second);
+                    ConsumeParentAttribute(wid, attrPair.first, &reader, name);
+                }
+            }
+        };
+
         const AZ::SerializeContext::ClassElement* element = dataNode->GetElementMetadata();
         if (element)
         {
             consumeAttributes(element->m_attributes, element->m_name);
-            const AZ::Edit::ElementData* elementEdit = dataNode->GetElementEditMetadata();
+
-            if (elementEdit)
+            if (const AZ::Edit::ElementData* elementEdit = dataNode->GetElementEditMetadata();
+                elementEdit != nullptr)
             {
                 consumeAttributes(elementEdit->m_attributes, elementEdit->m_name);
             }
-        }
 
-        if (dataNode->GetClassMetadata())
+            const AZ::SerializeContext::ClassElement* parentElement = parent != dataNode ?
-        {
+                dataNode->GetElementMetadata() :
-            const AZ::Edit::ClassData* classEditData = dataNode->GetClassMetadata()->m_editData;
+                nullptr;
-            if (classEditData)
+
+            if (parentElement != nullptr)
             {
-                for (auto it = classEditData->m_elements.begin(); it != classEditData->m_elements.end(); ++it)
+                // Reuse the current instance element name for the debug name
+                consumeParentAttributes(parentElement->m_attributes, element->m_name);
+
+                if (const AZ::Edit::ElementData* elementEdit = parent->GetElementEditMetadata();
+                    elementEdit != nullptr)
                 {
-                    consumeAttributes(it->m_attributes, it->m_name);
+                    consumeParentAttributes(elementEdit->m_attributes, elementEdit->m_name);
                 }
             }
         }

Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyEnumComboBoxCtrl.hxx

@@ -66,6 +66,12 @@ namespace AzToolsFramework
     class GenericEnumPropertyComboBoxHandler
         : public GenericComboBoxHandler<ValueType>
     {
+        virtual void ConsumeParentAttribute(GenericComboBoxCtrlBase* GUI, AZ::u32 attrib, PropertyAttributeReader* attrValue, const char* debugName) override
+        {
+            // Simply re-route to ConsumeAttribute since no special logic is needed.
+            ConsumeAttribute(GUI, attrib, attrValue, debugName);
+        }
+
         virtual void ConsumeAttribute(GenericComboBoxCtrlBase* GUI, AZ::u32 attrib, PropertyAttributeReader* attrValue, const char* debugName) override
         {
             (void)debugName;

Gems/SurfaceData/Code/Include/SurfaceData/SurfaceTag.h

@@ -19,7 +19,8 @@ namespace SurfaceData
     {
     public:
         AZ_CLASS_ALLOCATOR(SurfaceTag, AZ::SystemAllocator, 0);
-        AZ_RTTI(SurfaceTag, "{67C8C6ED-F32A-443E-A777-1CAE48B22CD7}");
+        AZ_TYPE_INFO(SurfaceTag, "{67C8C6ED-F32A-443E-A777-1CAE48B22CD7}");
+
         static void Reflect(AZ::ReflectContext* context);
 
         SurfaceTag()
@@ -47,6 +48,8 @@ namespace SurfaceData
             m_surfaceTagCrc = AZ::Crc32(value.data());
         }
 
+        AZStd::string GetDisplayName() const;
+
         static AZStd::vector<AZStd::pair<AZ::u32, AZStd::string>> GetRegisteredTags();
 
     private:
@@ -54,8 +57,6 @@ namespace SurfaceData
 
         AZStd::vector<AZStd::pair<AZ::u32, AZStd::string>> BuildSelectableTagList() const;
 
-        AZStd::string GetDisplayName() const;
-
         AZ::u32 m_surfaceTagCrc;
     };
 

Gems/Terrain/Code/Source/Components/TerrainPhysicsColliderComponent.cpp

@@ -17,11 +17,14 @@
 #include <AzCore/RTTI/BehaviorContext.h>
 #include <AzCore/Serialization/EditContext.h>
 #include <AzCore/Serialization/SerializeContext.h>
+#include <AzCore/std/sort.h>
 
 #include <AzFramework/Physics/Material.h>
 #include <AzFramework/Physics/PhysicsSystem.h>
 #include <AzFramework/Terrain/TerrainDataRequestBus.h>
 
+#include <EditorSelectableTagListProvider.h>
+
 namespace Terrain
 {
     void TerrainPhysicsSurfaceMaterialMapping::Reflect(AZ::ReflectContext* context)
@@ -45,6 +48,8 @@ namespace Terrain
                     ->DataElement(
                         AZ::Edit::UIHandlers::ComboBox, &TerrainPhysicsSurfaceMaterialMapping::m_surfaceTag, "Surface Tag",
                         "Surface type to map to a physics material.")
+                    ->Attribute(AZ::Edit::Attributes::EnumValues, &TerrainPhysicsSurfaceMaterialMapping::BuildSelectableTagList)
+
                     ->DataElement(AZ::Edit::UIHandlers::Default, &TerrainPhysicsSurfaceMaterialMapping::m_materialId, "Material ID", "")
                     ->ElementAttribute(Physics::Attributes::MaterialLibraryAssetId, &TerrainPhysicsSurfaceMaterialMapping::GetMaterialLibraryId)
                     ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
@@ -53,6 +58,30 @@ namespace Terrain
         }
     }
 
+    AZStd::vector<AZStd::pair<AZ::u32, AZStd::string>> TerrainPhysicsSurfaceMaterialMapping::BuildSelectableTagList() const
+    {
+        AZ_PROFILE_FUNCTION(Entity);
+
+        if (m_tagListProvider)
+        {
+            AZStd::vector<AZStd::pair<AZ::u32, AZStd::string>> selectableTags = AZStd::move(m_tagListProvider->BuildSelectableTagList());
+
+            // Insert the tag currently in use by this mapping
+            selectableTags.push_back({ m_surfaceTag, m_surfaceTag.GetDisplayName() });
+
+            // Sorting for consistency
+            AZStd::sort(selectableTags.begin(), selectableTags.end(), [](const auto& lhs, const auto& rhs) {return lhs.second < rhs.second; });
+            return selectableTags;
+        }
+
+        return SurfaceData::SurfaceTag::GetRegisteredTags();
+    }
+
+    void TerrainPhysicsSurfaceMaterialMapping::SetTagListProvider(const EditorSelectableTagListProvider* tagListProvider)
+    {
+        m_tagListProvider = tagListProvider;
+    }
+
     AZ::Data::AssetId TerrainPhysicsSurfaceMaterialMapping::GetMaterialLibraryId()
     {
         if (const auto* physicsSystem = AZ::Interface<AzPhysics::SystemInterface>::Get())

Gems/Terrain/Code/Source/Components/TerrainPhysicsColliderComponent.h

@@ -25,6 +25,8 @@ namespace LmbrCentral
 
 namespace Terrain
 {
+    class EditorSelectableTagListProvider;
+
     static const uint8_t InvalidSurfaceTagIndex = 0xFF;
 
     struct TerrainPhysicsSurfaceMaterialMapping final
@@ -33,12 +35,15 @@ namespace Terrain
         AZ_CLASS_ALLOCATOR(TerrainPhysicsSurfaceMaterialMapping, AZ::SystemAllocator, 0);
         AZ_RTTI(TerrainPhysicsSurfaceMaterialMapping, "{A88B5289-DFCD-4564-8395-E2177DFE5B18}");
         static void Reflect(AZ::ReflectContext* context);
+        AZStd::vector<AZStd::pair<AZ::u32, AZStd::string>> BuildSelectableTagList() const;
+        void SetTagListProvider(const EditorSelectableTagListProvider* tagListProvider);
 
         SurfaceData::SurfaceTag m_surfaceTag;
         Physics::MaterialId m_materialId;
 
     private:
         static AZ::Data::AssetId GetMaterialLibraryId();
+        const EditorSelectableTagListProvider* m_tagListProvider = nullptr;
     };
 
     class TerrainPhysicsColliderConfig

Gems/Terrain/Code/Source/Components/TerrainSurfaceGradientListComponent.cpp

@@ -11,9 +11,11 @@
 #include <AzCore/RTTI/BehaviorContext.h>
 #include <AzCore/Serialization/EditContext.h>
 #include <AzCore/Serialization/SerializeContext.h>
+#include <AzCore/std/sort.h>
 
 #include <GradientSignal/Ebuses/GradientRequestBus.h>
 #include <TerrainSystem/TerrainSystemBus.h>
+#include <EditorSelectableTagListProvider.h>
 
 namespace Terrain
 {
@@ -44,6 +46,7 @@ namespace Terrain
                     ->DataElement(
                         AZ::Edit::UIHandlers::Default, &TerrainSurfaceGradientMapping::m_surfaceTag, "Surface Tag",
                         "Surface type to map to this gradient.")
+                    ->Attribute(AZ::Edit::Attributes::EnumValues, &TerrainSurfaceGradientMapping::BuildSelectableTagList)
                 ;
             }
         }
@@ -60,6 +63,30 @@ namespace Terrain
         }
     }
 
+    AZStd::vector<AZStd::pair<AZ::u32, AZStd::string>> TerrainSurfaceGradientMapping::BuildSelectableTagList() const
+    {
+        AZ_PROFILE_FUNCTION(Entity);
+
+        if (m_tagListProvider)
+        {
+            AZStd::vector<AZStd::pair<AZ::u32, AZStd::string>> selectableTags = AZStd::move(m_tagListProvider->BuildSelectableTagList());
+
+            // Insert the tag currently in use by this mapping
+            selectableTags.push_back({ m_surfaceTag, m_surfaceTag.GetDisplayName() });
+
+            // Sorting for consistency
+            AZStd::sort(selectableTags.begin(), selectableTags.end(), [](const auto& lhs, const auto& rhs) {return lhs.second < rhs.second; });
+            return selectableTags;
+        }
+
+        return SurfaceData::SurfaceTag::GetRegisteredTags();
+    }
+
+    void TerrainSurfaceGradientMapping::SetTagListProvider(const EditorSelectableTagListProvider* tagListProvider)
+    {
+        m_tagListProvider = tagListProvider;
+    }
+
     void TerrainSurfaceGradientListConfig::Reflect(AZ::ReflectContext* context)
     {
         TerrainSurfaceGradientMapping::Reflect(context);

Gems/Terrain/Code/Source/Components/TerrainSurfaceGradientListComponent.h

@@ -25,6 +25,8 @@ namespace LmbrCentral
 
 namespace Terrain
 {
+    class EditorSelectableTagListProvider;
+
     class TerrainSurfaceGradientMapping final
     {
     public:
@@ -39,8 +41,14 @@ namespace Terrain
         {
         }
 
+        AZStd::vector<AZStd::pair<AZ::u32, AZStd::string>> BuildSelectableTagList() const;
+        void SetTagListProvider(const EditorSelectableTagListProvider* tagListProvider);
+
         AZ::EntityId m_gradientEntityId;
         SurfaceData::SurfaceTag m_surfaceTag;
+
+    private:
+        const EditorSelectableTagListProvider* m_tagListProvider = nullptr;
     };
 
     class TerrainSurfaceGradientListConfig : public AZ::ComponentConfig

Gems/Terrain/Code/Source/EditorComponents/EditorTerrainPhysicsColliderComponent.cpp

@@ -21,4 +21,38 @@ namespace Terrain
             typename BaseClassType::WrappedConfigType, 1>
         );
     }
+
+    void EditorTerrainPhysicsColliderComponent::Activate()
+    {
+        UpdateConfigurationTagProvider();
+        BaseClassType::Activate();
+    }
+
+    AZStd::unordered_set<AZ::u32> EditorTerrainPhysicsColliderComponent::GetSurfaceTagsInUse() const
+    {
+        AZStd::unordered_set<AZ::u32> tagsInUse;
+
+        for (const TerrainPhysicsSurfaceMaterialMapping& mapping : m_configuration.m_surfaceMaterialMappings)
+        {
+            AZ::u32 crc = mapping.m_surfaceTag;
+            tagsInUse.insert(crc);
+        }
+
+        return AZStd::move(tagsInUse);
+    }
+
+    AZ::u32 EditorTerrainPhysicsColliderComponent::ConfigurationChanged()
+    {
+        UpdateConfigurationTagProvider();
+        return BaseClassType::ConfigurationChanged();
+    }
+
+    void EditorTerrainPhysicsColliderComponent::UpdateConfigurationTagProvider()
+    {
+        for (TerrainPhysicsSurfaceMaterialMapping& mapping : m_configuration.m_surfaceMaterialMappings)
+        {
+            mapping.SetTagListProvider(this);
+        }
+    }
+
 }

Gems/Terrain/Code/Source/EditorComponents/EditorTerrainPhysicsColliderComponent.h

@@ -11,22 +11,34 @@
 #include <Components/TerrainPhysicsColliderComponent.h>
 #include <AzToolsFramework/ToolsComponents/EditorComponentBase.h>
 #include <LmbrCentral/Component/EditorWrappedComponentBase.h>
+#include <EditorSelectableTagListProvider.h>
 
 namespace Terrain
 {
     class EditorTerrainPhysicsColliderComponent
         : public LmbrCentral::EditorWrappedComponentBase<TerrainPhysicsColliderComponent, TerrainPhysicsColliderConfig>
+        , public EditorSelectableTagListProvider
     {
     public:
         using BaseClassType = LmbrCentral::EditorWrappedComponentBase<TerrainPhysicsColliderComponent, TerrainPhysicsColliderConfig>;
         AZ_EDITOR_COMPONENT(EditorTerrainPhysicsColliderComponent, "{C43FAB8F-3968-46A6-920E-E84AEDED3DF5}", BaseClassType);
         static void Reflect(AZ::ReflectContext* context);
 
+        // AZ::Component interface implementation
+        void Activate() override;
+
         static constexpr auto s_categoryName = "Terrain";
         static constexpr auto s_componentName = "Terrain Physics Heightfield Collider";
         static constexpr auto s_componentDescription = "Provides terrain data to a physics collider in the form of a heightfield and surface->material mapping.";
         static constexpr auto s_icon = "Editor/Icons/Components/TerrainPhysicsCollider.svg";
         static constexpr auto s_viewportIcon = "Editor/Icons/Components/Viewport/TerrainPhysicsCollider.svg";
         static constexpr auto s_helpUrl = "";
+
+    private:
+        // EditorSelectableTagListProvider interface implementation
+        AZStd::unordered_set<AZ::u32> GetSurfaceTagsInUse() const override;
+
+        AZ::u32 ConfigurationChanged() override;
+        void UpdateConfigurationTagProvider();
     };
 }

Gems/Terrain/Code/Source/EditorComponents/EditorTerrainSurfaceGradientListComponent.cpp

@@ -20,4 +20,37 @@ namespace Terrain
             typename BaseClassType::WrappedConfigType, 1>
         );
     }
+
+    void EditorTerrainSurfaceGradientListComponent::Activate()
+    {
+        UpdateConfigurationTagProvider();
+        BaseClassType::Activate();
+    }
+
+    AZ::u32 EditorTerrainSurfaceGradientListComponent::ConfigurationChanged()
+    {
+        UpdateConfigurationTagProvider();
+        return BaseClassType::ConfigurationChanged();
+    }
+
+    void EditorTerrainSurfaceGradientListComponent::UpdateConfigurationTagProvider()
+    {
+        for (TerrainSurfaceGradientMapping& mapping : m_configuration.m_gradientSurfaceMappings)
+        {
+            mapping.SetTagListProvider(this);
+        }
+    }
+
+    AZStd::unordered_set<AZ::u32> EditorTerrainSurfaceGradientListComponent::GetSurfaceTagsInUse() const
+    {
+        AZStd::unordered_set<AZ::u32> tagsInUse;
+
+        for (const TerrainSurfaceGradientMapping& mapping : m_configuration.m_gradientSurfaceMappings)
+        {
+            AZ::u32 crc = mapping.m_surfaceTag;
+            tagsInUse.insert(crc);
+        }
+
+        return AZStd::move(tagsInUse);
+    }
 }

Gems/Terrain/Code/Source/EditorComponents/EditorTerrainSurfaceGradientListComponent.h

@@ -11,22 +11,34 @@
 #include <Components/TerrainSurfaceGradientListComponent.h>
 #include <AzToolsFramework/ToolsComponents/EditorComponentBase.h>
 #include <LmbrCentral/Component/EditorWrappedComponentBase.h>
+#include <EditorSelectableTagListProvider.h>
 
 namespace Terrain
 {
     class EditorTerrainSurfaceGradientListComponent
         : public LmbrCentral::EditorWrappedComponentBase<TerrainSurfaceGradientListComponent, TerrainSurfaceGradientListConfig>
+        , public EditorSelectableTagListProvider
     {
     public:
         using BaseClassType = LmbrCentral::EditorWrappedComponentBase<TerrainSurfaceGradientListComponent, TerrainSurfaceGradientListConfig>;
         AZ_EDITOR_COMPONENT(EditorTerrainSurfaceGradientListComponent, "{49831E91-A11F-4EFF-A824-6D85C284B934}", BaseClassType);
         static void Reflect(AZ::ReflectContext* context);
 
+        // AZ::Component interface implementation
+        void Activate() override;
+
         static constexpr const char* const s_categoryName = "Terrain";
         static constexpr const char* const s_componentName = "Terrain Surface Gradient List";
         static constexpr const char* const s_componentDescription = "Provides a mapping between gradients and surface tags for use by the terrain system.";
         static constexpr const char* const s_icon = "Editor/Icons/Components/TerrainSurfaceGradientList.svg";
         static constexpr const char* const s_viewportIcon = "Editor/Icons/Components/Viewport/TerrainSurfaceGradientList.svg";
         static constexpr const char* const s_helpUrl = "https://o3de.org/docs/user-guide/components/reference/terrain/surface-gradient-list/";
+
+    private:
+        // EditorSelectableTagListProvider interface implementation
+        AZStd::unordered_set<AZ::u32> GetSurfaceTagsInUse() const override;
+
+        AZ::u32 ConfigurationChanged() override;
+        void UpdateConfigurationTagProvider();
     };
 }

Gems/Terrain/Code/Source/EditorSelectableTagListProvider.cpp

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <EditorSelectableTagListProvider.h>
+#include <SurfaceData/SurfaceTag.h>
+
+namespace Terrain
+{
+    AZStd::vector<AZStd::pair<AZ::u32, AZStd::string>> EditorSelectableTagListProvider::BuildSelectableTagList() const
+    {
+        AZStd::vector<AZStd::pair<AZ::u32, AZStd::string>> availableTags = SurfaceData::SurfaceTag::GetRegisteredTags();
+
+        AZStd::unordered_set<AZ::u32> tagsInUse = AZStd::move(GetSurfaceTagsInUse());
+
+        // Filter out all tags in use from the list of registered tags
+        availableTags.erase(std::remove_if(availableTags.begin(), availableTags.end(),
+            [&tagsInUse](const auto& tag)-> bool
+        {
+            return tagsInUse.contains(tag.first);
+        }), availableTags.end());
+
+        return AZStd::move(availableTags);
+    }
+}

Gems/Terrain/Code/Source/EditorSelectableTagListProvider.h

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+#include <AzCore/std/containers/vector.h>
+#include <AzCore/std/string/string.h>
+#include <AzCore/std/containers/unordered_set.h>
+
+namespace Terrain
+{
+    //! Interface for a class providing information about surface tags available for selecting in Editor components.
+    class EditorSelectableTagListProvider
+    {
+    public:
+        //! Returns a list of available tags to be selected in the component.
+        virtual AZStd::vector<AZStd::pair<AZ::u32, AZStd::string>> BuildSelectableTagList() const;
+
+        //! Returns a set of CRC of all surface tags currently in use and not available for selecting.
+        virtual AZStd::unordered_set<AZ::u32> GetSurfaceTagsInUse() const = 0;
+    };
+}

Gems/Terrain/Code/terrain_editor_shared_files.cmake

@@ -25,6 +25,8 @@ set(FILES
     Source/EditorComponents/EditorTerrainSystemComponent.h
     Source/EditorTerrainModule.cpp
     Source/EditorTerrainModule.h
+    Source/EditorSelectableTagListProvider.h
+    Source/EditorSelectableTagListProvider.cpp
     Source/TerrainModule.cpp
     Source/TerrainModule.h
     Source/TerrainRenderer/EditorComponents/EditorTerrainSurfaceMaterialsListComponent.cpp