[2409] Csv Spawner Notification Bus

Gems/CsvSpawner/Code/Include/CsvSpawner/CsvSpawnerInterface.h

@@ -0,0 +1,75 @@
+/**
+ * Copyright (C) Robotec AI - All Rights Reserved
+ *
+ * This source code is protected under international copyright law.  All rights
+ * reserved and protected by the copyright holders.
+ * This file is confidential and only available to authorized individuals with
+ * the permission of the copyright holders.  If you encounter this file and do
+ * not have permission, please contact the copyright holders and delete this
+ * file.
+ */
+
+#pragma once
+
+#include <CsvSpawner/CsvSpawnerUtils.h>
+
+#include <AzCore/EBus/EBus.h>
+#include <AzCore/RTTI/BehaviorContext.h>
+
+namespace CsvSpawner
+{
+    /**
+     * @brief Interface for handling entity spawn events for Csv Spawner.
+     *
+     * CsvSpawnerInterface is an Event Bus interface that notifies multiple
+     * listeners when entity spawning begins and finishes.
+     */
+    class CsvSpawnerInterface : public AZ::EBusTraits
+    {
+    public:
+        AZ_RTTI(CsvSpawnerInterface, CsvSpawnerInterfaceTypeId);
+        virtual ~CsvSpawnerInterface() = default;
+
+        /**
+         * @brief Called when entity spawning begins.
+         * @param m_spawnInfo Struct holding information about entities to be spawned.
+         */
+        virtual void OnEntitiesSpawnBegin(CsvSpawnerUtils::SpawnInfo m_spawnInfo) = 0;
+
+        /**
+         * @brief Called when entity spawning finishes.
+         * @param m_spawnInfo Struct holding information about entities to be spawned.
+         * @param m_statusCode Status code indicating success, failure and warnings of the spawn.
+         */
+        virtual void OnEntitiesSpawnFinished(CsvSpawnerUtils::SpawnInfo m_spawnInfo, CsvSpawnerUtils::SpawnStatus m_statusCode) = 0;
+
+        /// EBus Configuration - Allows multiple listeners to handle events.
+        static constexpr AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
+    };
+
+    // Create an EBus using the notification interface
+    using CsvSpawnerNotificationBus = AZ::EBus<CsvSpawnerInterface>;
+
+    class CsvSpawnerNotificationBusHandler
+        : public CsvSpawnerNotificationBus::Handler
+        , public AZ::BehaviorEBusHandler
+    {
+    public:
+        AZ_EBUS_BEHAVIOR_BINDER(
+            CsvSpawnerNotificationBusHandler,
+            CsvSpawnerNotificationBusHandlerTypeId,
+            AZ::SystemAllocator,
+            OnEntitiesSpawnBegin,
+            OnEntitiesSpawnFinished);
+
+        void OnEntitiesSpawnBegin(CsvSpawnerUtils::SpawnInfo m_spawnInfo) override
+        {
+            Call(FN_OnEntitiesSpawnBegin, m_spawnInfo);
+        }
+
+        void OnEntitiesSpawnFinished(CsvSpawnerUtils::SpawnInfo m_spawnInfo, CsvSpawnerUtils::SpawnStatus m_statusCode) override
+        {
+            Call(FN_OnEntitiesSpawnFinished, m_spawnInfo, m_statusCode);
+        }
+    };
+} // namespace CsvSpawner

Gems/CsvSpawner/Code/Include/CsvSpawner/CsvSpawnerTypeIds.h

@@ -22,5 +22,7 @@ namespace CsvSpawner
     inline constexpr const char* CsvSpawnerComponentTypeId = "{59b31372-1f3c-4733-b61b-0fe94b5a8f3e}";
 
     // Interface TypeIds
-    inline constexpr const char* CsvSpawnerRequestsTypeId = "{77ACBD4E-069E-4610-8154-E1AC28CEE05A}";
+    inline constexpr const char* CsvSpawnerInterfaceTypeId = "{77ACBD4E-069E-4610-8154-E1AC28CEE05A}";
+    inline constexpr const char* CsvSpawnerNotificationBusHandlerTypeId = "{1F142F00-4E79-431B-9C1D-3AB157838FF8}";
+    inline constexpr const char* CsvSpawnerSpawnInfoTypeId = "{81E5A014-3232-4359-98F5-7F9D7152629E}";
 } // namespace CsvSpawner

Gems/CsvSpawner/Code/Source/CsvSpawner/CsvSpawnerComponent.h

@@ -10,8 +10,10 @@
 
 #pragma once
 
+#include <CsvSpawner/CsvSpawnerTypeIds.h>
+#include <CsvSpawner/CsvSpawnerUtils.h>
+
 #include "AzFramework/Terrain/TerrainDataRequestBus.h"
-#include "CsvSpawnerUtils.h"
 
 #include <AzCore/Component/Component.h>
 #include <AzCore/Component/TickBus.h>

Gems/CsvSpawner/Code/Source/CsvSpawner/CsvSpawnerCsvParser.cpp

@@ -8,12 +8,11 @@
  * permission, please contact the copyright holders and delete this file.
  */
 
-#include "CsvSpawnerUtils.h"
 #include <AzCore/Asset/AssetCommon.h>
 #include <AzCore/Math/Transform.h>
 #include <AzCore/Math/Vector3.h>
 #include <AzCore/std/string/string.h>
-#include <AzFramework/Spawnable/SpawnableEntitiesInterface.h>
+#include <CsvSpawner/CsvSpawnerUtils.h>
 #include <ROS2/Georeference/GeoreferenceBus.h>
 #include <csv/csv.hpp>
 

Gems/CsvSpawner/Code/Source/CsvSpawner/CsvSpawnerCsvParser.h

@@ -10,12 +10,8 @@
 
 #pragma once
 
-#include "CsvSpawnerUtils.h"
-#include <AzCore/Asset/AssetCommon.h>
-#include <AzCore/Math/Transform.h>
-#include <AzCore/Math/Vector3.h>
 #include <AzCore/std/string/string.h>
-#include <AzFramework/Spawnable/SpawnableEntitiesInterface.h>
+#include <CsvSpawner/CsvSpawnerUtils.h>
 
 namespace CsvSpawner::CsvSpawnerUtils
 {

Gems/CsvSpawner/Code/Source/CsvSpawner/CsvSpawnerEditorComponent.cpp

@@ -12,6 +12,7 @@
 #include "CsvSpawnerComponent.h"
 #include "CsvSpawnerCsvParser.h"
 #include "CsvSpawnerUtils.h"
+#include <CsvSpawner/CsvSpawnerInterface.h>
 
 #include <AzCore/Component/TransformBus.h>
 #include <AzCore/Debug/Trace.h>
@@ -26,6 +27,8 @@ namespace CsvSpawner
 {
     void CsvSpawnerEditorComponent::Reflect(AZ::ReflectContext* context)
     {
+        CsvSpawner::SpawnInfo::Reflect(context);
+
         AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(context);
         if (serializeContext)
         {
@@ -70,6 +73,12 @@ namespace CsvSpawner
                         "Settings to configure spawn behaviour in editor.");
             }
         }
+
+        if (const auto behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
+        {
+            behaviorContext->EBus<CsvSpawner::CsvSpawnerNotificationBus>("CsvSpawnerNotificationBus")
+                ->Handler<CsvSpawner::CsvSpawnerNotificationBusHandler>();
+        }
     }
 
     void CsvSpawnerEditorComponent::Activate()

Gems/CsvSpawner/Code/Source/CsvSpawner/CsvSpawnerEditorComponent.h

@@ -10,9 +10,12 @@
 
 #pragma once
 
-#include "CsvSpawnerUtils.h"
+#include <CsvSpawner/CsvSpawnerTypeIds.h>
+#include <CsvSpawner/CsvSpawnerUtils.h>
+
 #include "EditorConfigurations/CsvSpawnerEditorTerrainSettingsConfig.h"
 
+#include <API/ToolsApplicationAPI.h>
 #include <AzCore/Asset/AssetCommon.h>
 #include <AzCore/Component/TickBus.h>
 #include <AzFramework/Entity/EntityDebugDisplayBus.h>

Gems/CsvSpawner/Code/Source/CsvSpawner/CsvSpawnerUtils.cpp

@@ -11,11 +11,15 @@
 
 #include "CsvSpawnerUtils.h"
 
+#include "AzCore/std/smart_ptr/make_shared.h"
+
+#include <AzFramework/Physics/CollisionBus.h>
+#include <CsvSpawner/CsvSpawnerInterface.h>
+
 #include <AzCore/Asset/AssetSerializer.h>
 #include <AzCore/Serialization/EditContext.h>
 #include <AzCore/Serialization/SerializeContext.h>
 #include <AzFramework/Components/TransformComponent.h>
-#include <AzFramework/Physics/CollisionBus.h>
 #include <AzFramework/Physics/Common/PhysicsSceneQueries.h>
 #include <AzFramework/Physics/PhysicsScene.h>
 #include <AzFramework/Physics/PhysicsSystem.h>
@@ -37,6 +41,32 @@ namespace CsvSpawner::CsvSpawnerUtils
                 ->Field("Transform", &CsvSpawnableEntityInfo::m_transform)
                 ->Field("Name", &CsvSpawnableEntityInfo::m_name)
                 ->Field("Seed", &CsvSpawnableEntityInfo::m_seed);
+
+            if (AZ::EditContext* editContext = serializeContext->GetEditContext())
+            {
+                editContext->Class<CsvSpawnableEntityInfo>("Csv Spawnable Entity Info", "An entity configuration for spawning")
+                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                    ->DataElement(AZ::Edit::UIHandlers::Default, &CsvSpawnableEntityInfo::m_id, "ID", "Optional ID for the entity")
+                    ->DataElement(
+                        AZ::Edit::UIHandlers::Default, &CsvSpawnableEntityInfo::m_transform, "Transform", "Transform of the entity")
+                    ->DataElement(
+                        AZ::Edit::UIHandlers::Default,
+                        &CsvSpawnableEntityInfo::m_name,
+                        "Name",
+                        "Name of the spawnable entity configuration")
+                    ->DataElement(
+                        AZ::Edit::UIHandlers::Default, &CsvSpawnableEntityInfo::m_seed, "Seed", "Optional seed value for randomization");
+            }
+        }
+
+        if (auto* behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
+        {
+            behaviorContext->Class<CsvSpawnableEntityInfo>("CsvSpawnableEntityInfo")
+                ->Constructor<>()
+                ->Property("Id", BehaviorValueProperty(&CsvSpawnableEntityInfo::m_id))
+                ->Property("Transform", BehaviorValueProperty(&CsvSpawnableEntityInfo::m_transform))
+                ->Property("Name", BehaviorValueProperty(&CsvSpawnableEntityInfo::m_name))
+                ->Property("Seed", BehaviorValueProperty(&CsvSpawnableEntityInfo::m_seed));
         }
     }
     void CsvSpawnableAssetConfiguration::Reflect(AZ::ReflectContext* context)
@@ -193,6 +223,24 @@ namespace CsvSpawner::CsvSpawnerUtils
         const AZStd::string& physicsSceneName,
         AZ::EntityId parentId)
     {
+        SpawnInfo broadcastSpawnInfo =
+            SpawnInfo{ entitiesToSpawn, physicsSceneName, parentId }; // Spawn Info used in CsvSpawner EBus notify.
+        // SpawnStatus spawnStatusCode = SpawnStatus::Success; // Spawn Status Code used for CsvSpawner EBus notify -
+        // OnEntitiesSpawnFinished.
+        auto spawnStatusCode = AZStd::make_shared<SpawnStatus>(
+            SpawnStatus::Success); // Spawn Status Code used for CsvSpawner EBus notify - OnEntitiesSpawnFinished.
+
+        // Call CsvSpawner EBus notification - Begin
+        CsvSpawnerNotificationBus::Broadcast(&CsvSpawnerInterface::OnEntitiesSpawnBegin, broadcastSpawnInfo);
+
+        // Check if there are no entities to spawn
+        if (entitiesToSpawn.empty())
+        {
+            *spawnStatusCode |= SpawnStatus::Fail;
+            CsvSpawnerNotificationBus::Broadcast(&CsvSpawnerInterface::OnEntitiesSpawnFinished, broadcastSpawnInfo, *spawnStatusCode);
+            return {};
+        }
+
         auto sceneInterface = AZ::Interface<AzPhysics::SceneInterface>::Get();
         AZ_Assert(sceneInterface, "Unable to get physics scene interface");
         const auto sceneHandle = sceneInterface->GetSceneHandle(physicsSceneName);
@@ -201,6 +249,8 @@ namespace CsvSpawner::CsvSpawnerUtils
         auto spawner = AZ::Interface<AzFramework::SpawnableEntitiesDefinition>::Get();
         AZ_Assert(spawner, "Unable to get spawnable entities definition");
 
+        auto pendingSpawns = AZStd::make_shared<AZStd::atomic_int>(static_cast<int>(entitiesToSpawn.size()));
+
         // get parent transform
         AZ::Transform parentTransform = AZ::Transform::CreateIdentity();
         if (parentId.IsValid())
@@ -221,6 +271,9 @@ namespace CsvSpawner::CsvSpawnerUtils
             if (!spawnableAssetConfiguration.contains(entityConfig.m_name))
             {
                 AZ_Error("CsvSpawner", false, "SpawnableAssetConfiguration %s not found", entityConfig.m_name.c_str());
+
+                // Add notify code status
+                *spawnStatusCode |= SpawnStatus::Warning;
                 continue;
             }
 
@@ -250,6 +303,9 @@ namespace CsvSpawner::CsvSpawnerUtils
                 }
                 else
                 {
+                    // Add notify code status
+                    *spawnStatusCode |= SpawnStatus::Warning;
+
                     continue; // Skip this entity if we can't find a valid position and
                               // place on terrain is enabled.
                 }
@@ -259,10 +315,13 @@ namespace CsvSpawner::CsvSpawnerUtils
             AzFramework::EntitySpawnTicket ticket(spawnable);
             // Set the pre-spawn callback to set the name of the root entity to the name
             // of the spawnable
-            optionalArgs.m_preInsertionCallback = [transform](auto id, auto view)
+            optionalArgs.m_preInsertionCallback = [transform, &spawnStatusCode](auto id, auto view)
             {
                 if (view.empty())
                 {
+                    // Add notify code status
+                    *spawnStatusCode |= SpawnStatus::Warning | SpawnStatus::Stopped;
+
                     return;
                 }
                 AZ::Entity* root = *view.begin();
@@ -272,23 +331,94 @@ namespace CsvSpawner::CsvSpawnerUtils
                 transformInterface->SetWorldTM(transform);
             };
             optionalArgs.m_completionCallback =
-                [parentId](
+                [parentId, spawnStatusCode, pendingSpawns, broadcastSpawnInfo](
                     [[maybe_unused]] AzFramework::EntitySpawnTicket::Id ticketId, AzFramework::SpawnableConstEntityContainerView view)
             {
                 if (view.empty())
                 {
-                    return;
+                    *spawnStatusCode |= SpawnStatus::Warning | SpawnStatus::Stopped;
+                }
+                else
+                {
+                    const AZ::Entity* root = *view.begin();
+                    AZ::TransformBus::Event(root->GetId(), &AZ::TransformBus::Events::SetParent, parentId);
+                }
+
+                // Decrement the pending counter
+                const int remaining = --(*pendingSpawns);
+                if (remaining == 0)
+                {
+                    // All spawns are finished, now broadcast finished notification
+                    CsvSpawnerNotificationBus::Broadcast(
+                        &CsvSpawnerInterface::OnEntitiesSpawnFinished, broadcastSpawnInfo, *spawnStatusCode);
                 }
-                const AZ::Entity* root = *view.begin();
-                AZ::TransformBus::Event(root->GetId(), &AZ::TransformBus::Events::SetParent, parentId);
             };
             optionalArgs.m_priority = AzFramework::SpawnablePriority_Lowest;
             spawner->SpawnAllEntities(ticket, optionalArgs);
             tickets[entityConfig.m_id] = AZStd::move(ticket);
         }
+
         return tickets;
     }
 
+    void SpawnInfo::Reflect(AZ::ReflectContext* context)
+    {
+        if (auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
+        {
+            // Reflect SpawnStatus enum
+            serializeContext->Enum<SpawnStatus>()
+                ->Version(0)
+                ->Value("Success", SpawnStatus::Success)
+                ->Value("Fail", SpawnStatus::Fail)
+                ->Value("Stopped", SpawnStatus::Stopped)
+                ->Value("Warning", SpawnStatus::Warning);
+
+            // Reflect SpawnInfo struct
+            serializeContext->Class<SpawnInfo>()
+                ->Version(0)
+                ->Field("EntitiesToSpawn", &SpawnInfo::m_entitiesToSpawn)
+                ->Field("PhysicsSceneName", &SpawnInfo::m_physicsSceneName)
+                ->Field("SpawnerParentEntityId", &SpawnInfo::m_spawnerParentEntityId);
+
+            if (auto* editContext = serializeContext->GetEditContext())
+            {
+                editContext->Class<SpawnInfo>("Spawn Info", "Information about entities being spawned")
+                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                    ->DataElement(
+                        AZ::Edit::UIHandlers::Default,
+                        &SpawnInfo::m_entitiesToSpawn,
+                        "Entities to Spawn",
+                        "List of entities to be spawned.")
+                    ->DataElement(
+                        AZ::Edit::UIHandlers::Default,
+                        &SpawnInfo::m_physicsSceneName,
+                        "Physics Scene",
+                        "Name of the physics scene where entities will be spawned.")
+                    ->DataElement(
+                        AZ::Edit::UIHandlers::Default,
+                        &SpawnInfo::m_spawnerParentEntityId,
+                        "Parent Entity",
+                        "Parent entity ID responsible for spawning.");
+            }
+        }
+
+        if (auto* behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
+        {
+            behaviorContext->EnumProperty<static_cast<int>(CsvSpawnerUtils::SpawnStatus::Success)>("SpawnStatus_Success");
+            behaviorContext->EnumProperty<static_cast<int>(CsvSpawnerUtils::SpawnStatus::Fail)>("SpawnStatus_Fail");
+            behaviorContext->EnumProperty<static_cast<int>(CsvSpawnerUtils::SpawnStatus::Stopped)>("SpawnStatus_Stopped");
+            behaviorContext->EnumProperty<static_cast<int>(CsvSpawnerUtils::SpawnStatus::Warning)>("SpawnStatus_Warning");
+
+            behaviorContext->Class<SpawnInfo>("SpawnInfo")
+                ->Constructor()
+                ->Attribute(AZ::Script::Attributes::Category, "CsvSpawner")
+                ->Attribute(AZ::Script::Attributes::Module, "editor")
+                ->Property("m_entitiesToSpawn", BehaviorValueProperty(&SpawnInfo::m_entitiesToSpawn))
+                ->Property("m_physicsSceneName", BehaviorValueProperty(&SpawnInfo::m_physicsSceneName))
+                ->Property("m_spawnerParentEntityId", BehaviorValueProperty(&SpawnInfo::m_spawnerParentEntityId));
+        }
+    }
+
     bool IsTerrainAvailable()
     {
         return AzFramework::Terrain::TerrainDataRequestBus::HasHandlers();